simplestore: use a custom store for the simple store repo

Before, we used the default store, which was based on fncache
and dotencode. After attempting to port tests to work with the
simple store, I realized that fncache was more trouble than it is
worth.

This commit implements a proper store type for the simple repo -
one that isn't based off fncache.

This causes a number of new test failures because of tests
expecting the full fncache store filename encoding. I may
extend the store format in a subsequent commit to take the
filename encoding parts of fncache that we can take
(basically everything except hash encoding, since that isn't
reversible). But for now, let's use encoded store.

As part of this, we implement proper requirements support for
repos created with the simple store. This should have been
done from the beginning, as a requirement is needed to lock
out clients that don't understand a storage format.

A new hghave feature advertising the presence of fncache in repos
has been added. Most tests touching the fncache are now conditional
on that feature.

Other tests have added the optional repo requirement to output.

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

tests/hghave.py

@@ -1,772 +1,777 b''
 from __future__ import absolute_import
 
 import errno
 import os
 import re
 import socket
 import stat
 import subprocess
 import sys
 import tempfile
 
 tempprefix = 'hg-hghave-'
 
 checks = {
     "true": (lambda: True, "yak shaving"),
     "false": (lambda: False, "nail clipper"),
 }
 
 def check(name, desc):
     """Registers a check function for a feature."""
     def decorator(func):
         checks[name] = (func, desc)
         return func
     return decorator
 
 def checkvers(name, desc, vers):
     """Registers a check function for each of a series of versions.
 
     vers can be a list or an iterator"""
     def decorator(func):
         def funcv(v):
             def f():
                 return func(v)
             return f
         for v in vers:
             v = str(v)
             f = funcv(v)
             checks['%s%s' % (name, v.replace('.', ''))] = (f, desc % v)
         return func
     return decorator
 
 def checkfeatures(features):
     result = {
         'error': [],
         'missing': [],
         'skipped': [],
     }
 
     for feature in features:
         negate = feature.startswith('no-')
         if negate:
             feature = feature[3:]
 
         if feature not in checks:
             result['missing'].append(feature)
             continue
 
         check, desc = checks[feature]
         try:
             available = check()
         except Exception:
             result['error'].append('hghave check failed: %s' % feature)
             continue
 
         if not negate and not available:
             result['skipped'].append('missing feature: %s' % desc)
         elif negate and available:
             result['skipped'].append('system supports %s' % desc)
 
     return result
 
 def require(features):
     """Require that features are available, exiting if not."""
     result = checkfeatures(features)
 
     for missing in result['missing']:
         sys.stderr.write('skipped: unknown feature: %s\n' % missing)
     for msg in result['skipped']:
         sys.stderr.write('skipped: %s\n' % msg)
     for msg in result['error']:
         sys.stderr.write('%s\n' % msg)
 
     if result['missing']:
         sys.exit(2)
 
     if result['skipped'] or result['error']:
         sys.exit(1)
 
 def matchoutput(cmd, regexp, ignorestatus=False):
     """Return the match object if cmd executes successfully and its output
     is matched by the supplied regular expression.
     """
     r = re.compile(regexp)
     try:
         p = subprocess.Popen(
             cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
     except OSError as e:
         if e.errno != errno.ENOENT:
             raise
         ret = -1
     ret = p.wait()
     s = p.stdout.read()
     return (ignorestatus or not ret) and r.search(s)
 
 @check("baz", "GNU Arch baz client")
 def has_baz():
     return matchoutput('baz --version 2>&1', br'baz Bazaar version')
 
 @check("bzr", "Canonical's Bazaar client")
 def has_bzr():
     try:
         import bzrlib
         import bzrlib.bzrdir
         import bzrlib.errors
         import bzrlib.revision
         import bzrlib.revisionspec
         bzrlib.revisionspec.RevisionSpec
         return bzrlib.__doc__ is not None
     except (AttributeError, ImportError):
         return False
 
 @checkvers("bzr", "Canonical's Bazaar client >= %s", (1.14,))
 def has_bzr_range(v):
     major, minor = v.split('.')[0:2]
     try:
         import bzrlib
         return (bzrlib.__doc__ is not None
                 and bzrlib.version_info[:2] >= (int(major), int(minor)))
     except ImportError:
         return False
 
 @check("chg", "running with chg")
 def has_chg():
     return 'CHGHG' in os.environ
 
 @check("cvs", "cvs client/server")
 def has_cvs():
     re = br'Concurrent Versions System.*?server'
     return matchoutput('cvs --version 2>&1', re) and not has_msys()
 
 @check("cvs112", "cvs client/server 1.12.* (not cvsnt)")
 def has_cvs112():
     re = br'Concurrent Versions System \(CVS\) 1.12.*?server'
     return matchoutput('cvs --version 2>&1', re) and not has_msys()
 
 @check("cvsnt", "cvsnt client/server")
 def has_cvsnt():
     re = br'Concurrent Versions System \(CVSNT\) (\d+).(\d+).*\(client/server\)'
     return matchoutput('cvsnt --version 2>&1', re)
 
 @check("darcs", "darcs client")
 def has_darcs():
     return matchoutput('darcs --version', br'\b2\.([2-9]|\d{2})', True)
 
 @check("mtn", "monotone client (>= 1.0)")
 def has_mtn():
     return matchoutput('mtn --version', br'monotone', True) and not matchoutput(
         'mtn --version', br'monotone 0\.', True)
 
 @check("eol-in-paths", "end-of-lines in paths")
 def has_eol_in_paths():
     try:
         fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix, suffix='\n\r')
         os.close(fd)
         os.remove(path)
         return True
     except (IOError, OSError):
         return False
 
 @check("execbit", "executable bit")
 def has_executablebit():
     try:
         EXECFLAGS = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
         fh, fn = tempfile.mkstemp(dir='.', prefix=tempprefix)
         try:
             os.close(fh)
             m = os.stat(fn).st_mode & 0o777
             new_file_has_exec = m & EXECFLAGS
             os.chmod(fn, m ^ EXECFLAGS)
             exec_flags_cannot_flip = ((os.stat(fn).st_mode & 0o777) == m)
         finally:
             os.unlink(fn)
     except (IOError, OSError):
         # we don't care, the user probably won't be able to commit anyway
         return False
     return not (new_file_has_exec or exec_flags_cannot_flip)
 
 @check("icasefs", "case insensitive file system")
 def has_icasefs():
     # Stolen from mercurial.util
     fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix)
     os.close(fd)
     try:
         s1 = os.stat(path)
         d, b = os.path.split(path)
         p2 = os.path.join(d, b.upper())
         if path == p2:
             p2 = os.path.join(d, b.lower())
         try:
             s2 = os.stat(p2)
             return s2 == s1
         except OSError:
             return False
     finally:
         os.remove(path)
 
 @check("fifo", "named pipes")
 def has_fifo():
     if getattr(os, "mkfifo", None) is None:
         return False
     name = tempfile.mktemp(dir='.', prefix=tempprefix)
     try:
         os.mkfifo(name)
         os.unlink(name)
         return True
     except OSError:
         return False
 
 @check("killdaemons", 'killdaemons.py support')
 def has_killdaemons():
     return True
 
 @check("cacheable", "cacheable filesystem")
 def has_cacheable_fs():
     from mercurial import util
 
     fd, path = tempfile.mkstemp(dir='.', prefix=tempprefix)
     os.close(fd)
     try:
         return util.cachestat(path).cacheable()
     finally:
         os.remove(path)
 
 @check("lsprof", "python lsprof module")
 def has_lsprof():
     try:
         import _lsprof
         _lsprof.Profiler # silence unused import warning
         return True
     except ImportError:
         return False
 
 def gethgversion():
     m = matchoutput('hg --version --quiet 2>&1', br'(\d+)\.(\d+)')
     if not m:
         return (0, 0)
     return (int(m.group(1)), int(m.group(2)))
 
 @checkvers("hg", "Mercurial >= %s",
             list([(1.0 * x) / 10 for x in range(9, 99)]))
 def has_hg_range(v):
     major, minor = v.split('.')[0:2]
     return gethgversion() >= (int(major), int(minor))
 
 @check("hg08", "Mercurial >= 0.8")
 def has_hg08():
     if checks["hg09"][0]():
         return True
     return matchoutput('hg help annotate 2>&1', '--date')
 
 @check("hg07", "Mercurial >= 0.7")
 def has_hg07():
     if checks["hg08"][0]():
         return True
     return matchoutput('hg --version --quiet 2>&1', 'Mercurial Distributed SCM')
 
 @check("hg06", "Mercurial >= 0.6")
 def has_hg06():
     if checks["hg07"][0]():
         return True
     return matchoutput('hg --version --quiet 2>&1', 'Mercurial version')
 
 @check("gettext", "GNU Gettext (msgfmt)")
 def has_gettext():
     return matchoutput('msgfmt --version', br'GNU gettext-tools')
 
 @check("git", "git command line client")
 def has_git():
     return matchoutput('git --version 2>&1', br'^git version')
 
 def getgitversion():
     m = matchoutput('git --version 2>&1', br'git version (\d+)\.(\d+)')
     if not m:
         return (0, 0)
     return (int(m.group(1)), int(m.group(2)))
 
 # https://github.com/git-lfs/lfs-test-server
 @check("lfs-test-server", "git-lfs test server")
 def has_lfsserver():
     exe = 'lfs-test-server'
     if has_windows():
         exe = 'lfs-test-server.exe'
     return any(
         os.access(os.path.join(path, exe), os.X_OK)
         for path in os.environ["PATH"].split(os.pathsep)
     )
 
 @checkvers("git", "git client (with ext::sh support) version >= %s", (1.9,))
 def has_git_range(v):
     major, minor = v.split('.')[0:2]
     return getgitversion() >= (int(major), int(minor))
 
 @check("docutils", "Docutils text processing library")
 def has_docutils():
     try:
         import docutils.core
         docutils.core.publish_cmdline # silence unused import
         return True
     except ImportError:
         return False
 
 def getsvnversion():
     m = matchoutput('svn --version --quiet 2>&1', br'^(\d+)\.(\d+)')
     if not m:
         return (0, 0)
     return (int(m.group(1)), int(m.group(2)))
 
 @checkvers("svn", "subversion client and admin tools >= %s", (1.3, 1.5))
 def has_svn_range(v):
     major, minor = v.split('.')[0:2]
     return getsvnversion() >= (int(major), int(minor))
 
 @check("svn", "subversion client and admin tools")
 def has_svn():
     return matchoutput('svn --version 2>&1', br'^svn, version') and \
         matchoutput('svnadmin --version 2>&1', br'^svnadmin, version')
 
 @check("svn-bindings", "subversion python bindings")
 def has_svn_bindings():
     try:
         import svn.core
         version = svn.core.SVN_VER_MAJOR, svn.core.SVN_VER_MINOR
         if version < (1, 4):
             return False
         return True
     except ImportError:
         return False
 
 @check("p4", "Perforce server and client")
 def has_p4():
     return (matchoutput('p4 -V', br'Rev\. P4/') and
             matchoutput('p4d -V', br'Rev\. P4D/'))
 
 @check("symlink", "symbolic links")
 def has_symlink():
     if getattr(os, "symlink", None) is None:
         return False
     name = tempfile.mktemp(dir='.', prefix=tempprefix)
     try:
         os.symlink(".", name)
         os.unlink(name)
         return True
     except (OSError, AttributeError):
         return False
 
 @check("hardlink", "hardlinks")
 def has_hardlink():
     from mercurial import util
     fh, fn = tempfile.mkstemp(dir='.', prefix=tempprefix)
     os.close(fh)
     name = tempfile.mktemp(dir='.', prefix=tempprefix)
     try:
         util.oslink(fn, name)
         os.unlink(name)
         return True
     except OSError:
         return False
     finally:
         os.unlink(fn)
 
 @check("hardlink-whitelisted", "hardlinks on whitelisted filesystems")
 def has_hardlink_whitelisted():
     from mercurial import util
     try:
         fstype = util.getfstype(b'.')
     except OSError:
         return False
     return fstype in util._hardlinkfswhitelist
 
 @check("rmcwd", "can remove current working directory")
 def has_rmcwd():
     ocwd = os.getcwd()
     temp = tempfile.mkdtemp(dir='.', prefix=tempprefix)
     try:
         os.chdir(temp)
         # On Linux, 'rmdir .' isn't allowed, but the other names are okay.
         # On Solaris and Windows, the cwd can't be removed by any names.
         os.rmdir(os.getcwd())
         return True
     except OSError:
         return False
     finally:
         os.chdir(ocwd)
         # clean up temp dir on platforms where cwd can't be removed
         try:
             os.rmdir(temp)
         except OSError:
             pass
 
 @check("tla", "GNU Arch tla client")
 def has_tla():
     return matchoutput('tla --version 2>&1', br'The GNU Arch Revision')
 
 @check("gpg", "gpg client")
 def has_gpg():
     return matchoutput('gpg --version 2>&1', br'GnuPG')
 
 @check("gpg2", "gpg client v2")
 def has_gpg2():
     return matchoutput('gpg --version 2>&1', br'GnuPG[^0-9]+2\.')
 
 @check("gpg21", "gpg client v2.1+")
 def has_gpg21():
     return matchoutput('gpg --version 2>&1', br'GnuPG[^0-9]+2\.(?!0)')
 
 @check("unix-permissions", "unix-style permissions")
 def has_unix_permissions():
     d = tempfile.mkdtemp(dir='.', prefix=tempprefix)
     try:
         fname = os.path.join(d, 'foo')
         for umask in (0o77, 0o07, 0o22):
             os.umask(umask)
             f = open(fname, 'w')
             f.close()
             mode = os.stat(fname).st_mode
             os.unlink(fname)
             if mode & 0o777 != ~umask & 0o666:
                 return False
         return True
     finally:
         os.rmdir(d)
 
 @check("unix-socket", "AF_UNIX socket family")
 def has_unix_socket():
     return getattr(socket, 'AF_UNIX', None) is not None
 
 @check("root", "root permissions")
 def has_root():
     return getattr(os, 'geteuid', None) and os.geteuid() == 0
 
 @check("pyflakes", "Pyflakes python linter")
 def has_pyflakes():
     return matchoutput("sh -c \"echo 'import re' 2>&1 | pyflakes\"",
                        br"<stdin>:1: 're' imported but unused",
                        True)
 
 @check("pylint", "Pylint python linter")
 def has_pylint():
     return matchoutput("pylint --help",
                        br"Usage:  pylint",
                        True)
 
 @check("clang-format", "clang-format C code formatter")
 def has_clang_format():
     return matchoutput("clang-format --help",
                        br"^OVERVIEW: A tool to format C/C\+\+[^ ]+ code.")
 
 @check("jshint", "JSHint static code analysis tool")
 def has_jshint():
     return matchoutput("jshint --version 2>&1", br"jshint v")
 
 @check("pygments", "Pygments source highlighting library")
 def has_pygments():
     try:
         import pygments
         pygments.highlight # silence unused import warning
         return True
     except ImportError:
         return False
 
 @check("outer-repo", "outer repo")
 def has_outer_repo():
     # failing for other reasons than 'no repo' imply that there is a repo
     return not matchoutput('hg root 2>&1',
                            br'abort: no repository found', True)
 
 @check("ssl", "ssl module available")
 def has_ssl():
     try:
         import ssl
         ssl.CERT_NONE
         return True
     except ImportError:
         return False
 
 @check("sslcontext", "python >= 2.7.9 ssl")
 def has_sslcontext():
     try:
         import ssl
         ssl.SSLContext
         return True
     except (ImportError, AttributeError):
         return False
 
 @check("defaultcacerts", "can verify SSL certs by system's CA certs store")
 def has_defaultcacerts():
     from mercurial import sslutil, ui as uimod
     ui = uimod.ui.load()
     return sslutil._defaultcacerts(ui) or sslutil._canloaddefaultcerts
 
 @check("defaultcacertsloaded", "detected presence of loaded system CA certs")
 def has_defaultcacertsloaded():
     import ssl
     from mercurial import sslutil, ui as uimod
 
     if not has_defaultcacerts():
         return False
     if not has_sslcontext():
         return False
 
     ui = uimod.ui.load()
     cafile = sslutil._defaultcacerts(ui)
     ctx = ssl.create_default_context()
     if cafile:
         ctx.load_verify_locations(cafile=cafile)
     else:
         ctx.load_default_certs()
 
     return len(ctx.get_ca_certs()) > 0
 
 @check("tls1.2", "TLS 1.2 protocol support")
 def has_tls1_2():
     from mercurial import sslutil
     return 'tls1.2' in sslutil.supportedprotocols
 
 @check("windows", "Windows")
 def has_windows():
     return os.name == 'nt'
 
 @check("system-sh", "system() uses sh")
 def has_system_sh():
     return os.name != 'nt'
 
 @check("serve", "platform and python can manage 'hg serve -d'")
 def has_serve():
     return True
 
 @check("test-repo", "running tests from repository")
 def has_test_repo():
     t = os.environ["TESTDIR"]
     return os.path.isdir(os.path.join(t, "..", ".hg"))
 
 @check("tic", "terminfo compiler and curses module")
 def has_tic():
     try:
         import curses
         curses.COLOR_BLUE
         return matchoutput('test -x "`which tic`"', br'')
     except ImportError:
         return False
 
 @check("msys", "Windows with MSYS")
 def has_msys():
     return os.getenv('MSYSTEM')
 
 @check("aix", "AIX")
 def has_aix():
     return sys.platform.startswith("aix")
 
 @check("osx", "OS X")
 def has_osx():
     return sys.platform == 'darwin'
 
 @check("osxpackaging", "OS X packaging tools")
 def has_osxpackaging():
     try:
         return (matchoutput('pkgbuild', br'Usage: pkgbuild ', ignorestatus=1)
                 and matchoutput(
                     'productbuild', br'Usage: productbuild ',
                     ignorestatus=1)
                 and matchoutput('lsbom', br'Usage: lsbom', ignorestatus=1)
                 and matchoutput(
                     'xar --help', br'Usage: xar', ignorestatus=1))
     except ImportError:
         return False
 
 @check('linuxormacos', 'Linux or MacOS')
 def has_linuxormacos():
     # This isn't a perfect test for MacOS. But it is sufficient for our needs.
     return sys.platform.startswith(('linux', 'darwin'))
 
 @check("docker", "docker support")
 def has_docker():
     pat = br'A self-sufficient runtime for'
     if matchoutput('docker --help', pat):
         if 'linux' not in sys.platform:
             # TODO: in theory we should be able to test docker-based
             # package creation on non-linux using boot2docker, but in
             # practice that requires extra coordination to make sure
             # $TESTTEMP is going to be visible at the same path to the
             # boot2docker VM. If we figure out how to verify that, we
             # can use the following instead of just saying False:
             # return 'DOCKER_HOST' in os.environ
             return False
 
         return True
     return False
 
 @check("debhelper", "debian packaging tools")
 def has_debhelper():
     # Some versions of dpkg say `dpkg', some say 'dpkg' (` vs ' on the first
     # quote), so just accept anything in that spot.
     dpkg = matchoutput('dpkg --version',
                        br"Debian .dpkg' package management program")
     dh = matchoutput('dh --help',
                      br'dh is a part of debhelper.', ignorestatus=True)
     dh_py2 = matchoutput('dh_python2 --help',
                          br'other supported Python versions')
     # debuild comes from the 'devscripts' package, though you might want
     # the 'build-debs' package instead, which has a dependency on devscripts.
     debuild = matchoutput('debuild --help',
                           br'to run debian/rules with given parameter')
     return dpkg and dh and dh_py2 and debuild
 
 @check("debdeps",
        "debian build dependencies (run dpkg-checkbuilddeps in contrib/)")
 def has_debdeps():
     # just check exit status (ignoring output)
     path = '%s/../contrib/debian/control' % os.environ['TESTDIR']
     return matchoutput('dpkg-checkbuilddeps %s' % path, br'')
 
 @check("demandimport", "demandimport enabled")
 def has_demandimport():
     # chg disables demandimport intentionally for performance wins.
     return ((not has_chg()) and os.environ.get('HGDEMANDIMPORT') != 'disable')
 
 @check("py3k", "running with Python 3.x")
 def has_py3k():
     return 3 == sys.version_info[0]
 
 @check("py3exe", "a Python 3.x interpreter is available")
 def has_python3exe():
     return 'PYTHON3' in os.environ
 
 @check("py3pygments", "Pygments available on Python 3.x")
 def has_py3pygments():
     if has_py3k():
         return has_pygments()
     elif has_python3exe():
         # just check exit status (ignoring output)
         py3 = os.environ['PYTHON3']
         return matchoutput('%s -c "import pygments"' % py3, br'')
     return False
 
 @check("pure", "running with pure Python code")
 def has_pure():
     return any([
         os.environ.get("HGMODULEPOLICY") == "py",
         os.environ.get("HGTEST_RUN_TESTS_PURE") == "--pure",
     ])
 
 @check("slow", "allow slow tests (use --allow-slow-tests)")
 def has_slow():
     return os.environ.get('HGTEST_SLOW') == 'slow'
 
 @check("hypothesis", "Hypothesis automated test generation")
 def has_hypothesis():
     try:
         import hypothesis
         hypothesis.given
         return True
     except ImportError:
         return False
 
 @check("unziplinks", "unzip(1) understands and extracts symlinks")
 def unzip_understands_symlinks():
     return matchoutput('unzip --help', br'Info-ZIP')
 
 @check("zstd", "zstd Python module available")
 def has_zstd():
     try:
         import mercurial.zstd
         mercurial.zstd.__version__
         return True
     except ImportError:
         return False
 
 @check("devfull", "/dev/full special file")
 def has_dev_full():
     return os.path.exists('/dev/full')
 
 @check("virtualenv", "Python virtualenv support")
 def has_virtualenv():
     try:
         import virtualenv
         virtualenv.ACTIVATE_SH
         return True
     except ImportError:
         return False
 
 @check("fsmonitor", "running tests with fsmonitor")
 def has_fsmonitor():
     return 'HGFSMONITOR_TESTS' in os.environ
 
 @check("fuzzywuzzy", "Fuzzy string matching library")
 def has_fuzzywuzzy():
     try:
         import fuzzywuzzy
         fuzzywuzzy.__version__
         return True
     except ImportError:
         return False
 
 @check("clang-libfuzzer", "clang new enough to include libfuzzer")
 def has_clang_libfuzzer():
     mat = matchoutput('clang --version', b'clang version (\d)')
     if mat:
         # libfuzzer is new in clang 6
         return int(mat.group(1)) > 5
     return False
 
 @check("xdiff", "xdiff algorithm")
 def has_xdiff():
     try:
         from mercurial import policy
         bdiff = policy.importmod('bdiff')
         return bdiff.xdiffblocks(b'', b'') == [(0, 0, 0, 0)]
     except (ImportError, AttributeError):
         return False
 
 @check('extraextensions', 'whether tests are running with extra extensions')
 def has_extraextensions():
     return 'HGTESTEXTRAEXTENSIONS' in os.environ
 
 def getrepofeatures():
     """Obtain set of repository features in use.
 
     HGREPOFEATURES can be used to define or remove features. It contains
     a space-delimited list of feature strings. Strings beginning with ``-``
     mean to remove.
     """
     # Default list provided by core.
     features = {
         'bundlerepo',
         'revlogstore',
+        'fncache',
     }
 
     # Features that imply other features.
     implies = {
-        'simplestore': ['-revlogstore', '-bundlerepo'],
+        'simplestore': ['-revlogstore', '-bundlerepo', '-fncache'],
     }
 
     for override in os.environ.get('HGREPOFEATURES', '').split(' '):
         if not override:
             continue
 
         if override.startswith('-'):
             if override[1:] in features:
                 features.remove(override[1:])
         else:
             features.add(override)
 
             for imply in implies.get(override, []):
                 if imply.startswith('-'):
                     if imply[1:] in features:
                         features.remove(imply[1:])
                 else:
                     features.add(imply)
 
     return features
 
 @check('reporevlogstore', 'repository using the default revlog store')
 def has_reporevlogstore():
     return 'revlogstore' in getrepofeatures()
 
 @check('reposimplestore', 'repository using simple storage extension')
 def has_reposimplestore():
     return 'simplestore' in getrepofeatures()
 
 @check('repobundlerepo', 'whether we can open bundle files as repos')
 def has_repobundlerepo():
     return 'bundlerepo' in getrepofeatures()
+
+@check('repofncache', 'repository has an fncache')
+def has_repofncache():
+    return 'fncache' in getrepofeatures()

tests/simplestorerepo.py

@@ -1,595 +1,664 b''
 # simplestorerepo.py - Extension that swaps in alternate repository storage.
 #
 # Copyright 2018 Gregory Szorc <[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.
 
 # To use this with the test suite:
 #
 #   $ HGREPOFEATURES="simplestore" ./run-tests.py \
 #       --extra-config-opt extensions.simplestore=`pwd`/simplestorerepo.py
 
 from __future__ import absolute_import
 
+import stat
+
 from mercurial.i18n import _
 from mercurial.node import (
     bin,
     hex,
     nullid,
     nullrev,
 )
 from mercurial.thirdparty import (
     cbor,
 )
 from mercurial import (
     ancestor,
     bundlerepo,
     error,
+    extensions,
     filelog,
+    localrepo,
     mdiff,
     pycompat,
     revlog,
+    store,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = 'ships-with-hg-core'
 
+REQUIREMENT = 'testonly-simplestore'
+
 def validatenode(node):
     if isinstance(node, int):
         raise ValueError('expected node; got int')
 
     if len(node) != 20:
         raise ValueError('expected 20 byte node')
 
 def validaterev(rev):
     if not isinstance(rev, int):
         raise ValueError('expected int')
 
 class filestorage(object):
     """Implements storage for a tracked path.
 
     Data is stored in the VFS in a directory corresponding to the tracked
     path.
 
     Index data is stored in an ``index`` file using CBOR.
 
     Fulltext data is stored in files having names of the node.
     """
 
     def __init__(self, svfs, path):
         self._svfs = svfs
         self._path = path
 
         self._storepath = b'/'.join([b'data', path])
         self._indexpath = b'/'.join([self._storepath, b'index'])
 
         indexdata = self._svfs.tryread(self._indexpath)
         if indexdata:
             indexdata = cbor.loads(indexdata)
 
         self._indexdata = indexdata or []
         self._indexbynode = {}
         self._indexbyrev = {}
         self.index = []
         self._refreshindex()
 
         # This is used by changegroup code :/
         self._generaldelta = True
         self.storedeltachains = False
 
         self.version = 1
 
     def _refreshindex(self):
         self._indexbynode.clear()
         self._indexbyrev.clear()
         self.index = []
 
         for i, entry in enumerate(self._indexdata):
             self._indexbynode[entry[b'node']] = entry
             self._indexbyrev[i] = entry
 
         self._indexbynode[nullid] = {
             b'node': nullid,
             b'p1': nullid,
             b'p2': nullid,
             b'linkrev': nullrev,
             b'flags': 0,
         }
 
         self._indexbyrev[nullrev] = {
             b'node': nullid,
             b'p1': nullid,
             b'p2': nullid,
             b'linkrev': nullrev,
             b'flags': 0,
         }
 
         for i, entry in enumerate(self._indexdata):
             p1rev, p2rev = self.parentrevs(self.rev(entry[b'node']))
 
             # start, length, rawsize, chainbase, linkrev, p1, p2, node
             self.index.append((0, 0, 0, -1, entry[b'linkrev'], p1rev, p2rev,
                                entry[b'node']))
 
         self.index.append((0, 0, 0, -1, -1, -1, -1, nullid))
 
     def __len__(self):
         return len(self._indexdata)
 
     def __iter__(self):
         return iter(range(len(self)))
 
     def revs(self, start=0, stop=None):
         step = 1
         if stop is not None:
             if start > stop:
                 step = -1
 
             stop += step
         else:
             stop = len(self)
 
         return range(start, stop, step)
 
     def parents(self, node):
         validatenode(node)
 
         if node not in self._indexbynode:
             raise KeyError('unknown node')
 
         entry = self._indexbynode[node]
 
         return entry[b'p1'], entry[b'p2']
 
     def parentrevs(self, rev):
         p1, p2 = self.parents(self._indexbyrev[rev][b'node'])
         return self.rev(p1), self.rev(p2)
 
     def rev(self, node):
         validatenode(node)
 
         try:
             self._indexbynode[node]
         except KeyError:
             raise error.LookupError(node, self._indexpath, _('no node'))
 
         for rev, entry in self._indexbyrev.items():
             if entry[b'node'] == node:
                 return rev
 
         raise error.ProgrammingError('this should not occur')
 
     def node(self, rev):
         validaterev(rev)
 
         return self._indexbyrev[rev][b'node']
 
     def lookup(self, node):
         if isinstance(node, int):
             return self.node(node)
 
         if len(node) == 20:
             self.rev(node)
             return node
 
         try:
             rev = int(node)
             if '%d' % rev != node:
                 raise ValueError
 
             if rev < 0:
                 rev = len(self) + rev
             if rev < 0 or rev >= len(self):
                 raise ValueError
 
             return self.node(rev)
         except (ValueError, OverflowError):
             pass
 
         if len(node) == 40:
             try:
                 rawnode = bin(node)
                 self.rev(rawnode)
                 return rawnode
             except TypeError:
                 pass
 
         raise error.LookupError(node, self._path, _('invalid lookup input'))
 
     def linkrev(self, rev):
         validaterev(rev)
 
         return self._indexbyrev[rev][b'linkrev']
 
     def flags(self, rev):
         validaterev(rev)
 
         return self._indexbyrev[rev][b'flags']
 
     def deltaparent(self, rev):
         validaterev(rev)
 
         p1node = self.parents(self.node(rev))[0]
         return self.rev(p1node)
 
     def candelta(self, baserev, rev):
         validaterev(baserev)
         validaterev(rev)
 
         if ((self.flags(baserev) & revlog.REVIDX_RAWTEXT_CHANGING_FLAGS)
             or (self.flags(rev) & revlog.REVIDX_RAWTEXT_CHANGING_FLAGS)):
             return False
 
         return True
 
     def rawsize(self, rev):
         validaterev(rev)
         node = self.node(rev)
         return len(self.revision(node, raw=True))
 
     def _processflags(self, text, flags, operation, raw=False):
         if flags == 0:
             return text, True
 
         validatehash = True
         # Depending on the operation (read or write), the order might be
         # reversed due to non-commutative transforms.
         orderedflags = revlog.REVIDX_FLAGS_ORDER
         if operation == 'write':
             orderedflags = reversed(orderedflags)
 
         for flag in orderedflags:
             # If a flagprocessor has been registered for a known flag, apply the
             # related operation transform and update result tuple.
             if flag & flags:
                 vhash = True
 
                 if flag not in revlog._flagprocessors:
                     message = _("missing processor for flag '%#x'") % (flag)
                     raise revlog.RevlogError(message)
 
                 processor = revlog._flagprocessors[flag]
                 if processor is not None:
                     readtransform, writetransform, rawtransform = processor
 
                     if raw:
                         vhash = rawtransform(self, text)
                     elif operation == 'read':
                         text, vhash = readtransform(self, text)
                     else:  # write operation
                         text, vhash = writetransform(self, text)
                 validatehash = validatehash and vhash
 
         return text, validatehash
 
     def checkhash(self, text, node, p1=None, p2=None, rev=None):
         if p1 is None and p2 is None:
             p1, p2 = self.parents(node)
         if node != revlog.hash(text, p1, p2):
             raise error.RevlogError(_("integrity check failed on %s") %
                 self._path)
 
     def revision(self, node, raw=False):
         validatenode(node)
 
         if node == nullid:
             return b''
 
         rev = self.rev(node)
         flags = self.flags(rev)
 
         path = b'/'.join([self._storepath, hex(node)])
         rawtext = self._svfs.read(path)
 
         text, validatehash = self._processflags(rawtext, flags, 'read', raw=raw)
         if validatehash:
             self.checkhash(text, node, rev=rev)
 
         return text
 
     def read(self, node):
         validatenode(node)
 
         revision = self.revision(node)
 
         if not revision.startswith(b'\1\n'):
             return revision
 
         start = revision.index(b'\1\n', 2)
         return revision[start + 2:]
 
     def renamed(self, node):
         validatenode(node)
 
         if self.parents(node)[0] != nullid:
             return False
 
         fulltext = self.revision(node)
         m = filelog.parsemeta(fulltext)[0]
 
         if m and 'copy' in m:
             return m['copy'], bin(m['copyrev'])
 
         return False
 
     def cmp(self, node, text):
         validatenode(node)
 
         t = text
 
         if text.startswith(b'\1\n'):
             t = b'\1\n\1\n' + text
 
         p1, p2 = self.parents(node)
 
         if revlog.hash(t, p1, p2) == node:
             return False
 
         if self.iscensored(self.rev(node)):
             return text != b''
 
         if self.renamed(node):
             t2 = self.read(node)
             return t2 != text
 
         return True
 
     def size(self, rev):
         validaterev(rev)
 
         node = self._indexbyrev[rev][b'node']
 
         if self.renamed(node):
             return len(self.read(node))
 
         if self.iscensored(rev):
             return 0
 
         return len(self.revision(node))
 
     def iscensored(self, rev):
         validaterev(rev)
 
         return self.flags(rev) & revlog.REVIDX_ISCENSORED
 
     def commonancestorsheads(self, a, b):
         validatenode(a)
         validatenode(b)
 
         a = self.rev(a)
         b = self.rev(b)
 
         ancestors = ancestor.commonancestorsheads(self.parentrevs, a, b)
         return pycompat.maplist(self.node, ancestors)
 
     def descendants(self, revs):
         # This is a copy of revlog.descendants()
         first = min(revs)
         if first == nullrev:
             for i in self:
                 yield i
             return
 
         seen = set(revs)
         for i in self.revs(start=first + 1):
             for x in self.parentrevs(i):
                 if x != nullrev and x in seen:
                     seen.add(i)
                     yield i
                     break
 
     # Required by verify.
     def files(self):
         entries = self._svfs.listdir(self._storepath)
 
         # Strip out undo.backup.* files created as part of transaction
         # recording.
         entries = [f for f in entries if not f.startswith('undo.backup.')]
 
         return [b'/'.join((self._storepath, f)) for f in entries]
 
     # Required by verify.
     def checksize(self):
         return 0, 0
 
     def add(self, text, meta, transaction, linkrev, p1, p2):
         if meta or text.startswith(b'\1\n'):
             text = filelog.packmeta(meta, text)
 
         return self.addrevision(text, transaction, linkrev, p1, p2)
 
     def addrevision(self, text, transaction, linkrev, p1, p2, node=None,
                     flags=0):
         validatenode(p1)
         validatenode(p2)
 
         if flags:
             node = node or revlog.hash(text, p1, p2)
 
         rawtext, validatehash = self._processflags(text, flags, 'write')
 
         node = node or revlog.hash(text, p1, p2)
 
         if node in self._indexbynode:
             return node
 
         if validatehash:
             self.checkhash(rawtext, node, p1=p1, p2=p2)
 
         path = b'/'.join([self._storepath, hex(node)])
 
         self._svfs.write(path, text)
 
         self._indexdata.append({
             b'node': node,
             b'p1': p1,
             b'p2': p2,
             b'linkrev': linkrev,
             b'flags': flags,
         })
 
         self._reflectindexupdate()
 
         return node
 
     def _reflectindexupdate(self):
         self._refreshindex()
         self._svfs.write(self._indexpath, cbor.dumps(self._indexdata))
 
     def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None):
         nodes = []
 
         transaction.addbackup(self._indexpath)
 
         for node, p1, p2, linknode, deltabase, delta, flags in deltas:
             linkrev = linkmapper(linknode)
 
             nodes.append(node)
 
             if node in self._indexbynode:
                 continue
 
             # Need to resolve the fulltext from the delta base.
             if deltabase == nullid:
                 text = mdiff.patch(b'', delta)
             else:
                 text = mdiff.patch(self.revision(deltabase), delta)
 
             self.addrevision(text, transaction, linkrev, p1, p2, flags)
 
             if addrevisioncb:
                 addrevisioncb(self, node)
 
         return nodes
 
     def revdiff(self, rev1, rev2):
         validaterev(rev1)
         validaterev(rev2)
 
         node1 = self.node(rev1)
         node2 = self.node(rev2)
 
         return mdiff.textdiff(self.revision(node1, raw=True),
                               self.revision(node2, raw=True))
 
     def headrevs(self):
         # Assume all revisions are heads by default.
         revishead = {rev: True for rev in self._indexbyrev}
 
         for rev, entry in self._indexbyrev.items():
             # Unset head flag for all seen parents.
             revishead[self.rev(entry[b'p1'])] = False
             revishead[self.rev(entry[b'p2'])] = False
 
         return [rev for rev, ishead in sorted(revishead.items())
                 if ishead]
 
     def heads(self, start=None, stop=None):
         # This is copied from revlog.py.
         if start is None and stop is None:
             if not len(self):
                 return [nullid]
             return [self.node(r) for r in self.headrevs()]
 
         if start is None:
             start = nullid
         if stop is None:
             stop = []
         stoprevs = set([self.rev(n) for n in stop])
         startrev = self.rev(start)
         reachable = {startrev}
         heads = {startrev}
 
         parentrevs = self.parentrevs
         for r in self.revs(start=startrev + 1):
             for p in parentrevs(r):
                 if p in reachable:
                     if r not in stoprevs:
                         reachable.add(r)
                     heads.add(r)
                 if p in heads and p not in stoprevs:
                     heads.remove(p)
 
         return [self.node(r) for r in heads]
 
     def children(self, node):
         validatenode(node)
 
         # This is a copy of revlog.children().
         c = []
         p = self.rev(node)
         for r in self.revs(start=p + 1):
             prevs = [pr for pr in self.parentrevs(r) if pr != nullrev]
             if prevs:
                 for pr in prevs:
                     if pr == p:
                         c.append(self.node(r))
             elif p == nullrev:
                 c.append(self.node(r))
         return c
 
     def getstrippoint(self, minlink):
 
         # This is largely a copy of revlog.getstrippoint().
         brokenrevs = set()
         strippoint = len(self)
 
         heads = {}
         futurelargelinkrevs = set()
         for head in self.headrevs():
             headlinkrev = self.linkrev(head)
             heads[head] = headlinkrev
             if headlinkrev >= minlink:
                 futurelargelinkrevs.add(headlinkrev)
 
         # This algorithm involves walking down the rev graph, starting at the
         # heads. Since the revs are topologically sorted according to linkrev,
         # once all head linkrevs are below the minlink, we know there are
         # no more revs that could have a linkrev greater than minlink.
         # So we can stop walking.
         while futurelargelinkrevs:
             strippoint -= 1
             linkrev = heads.pop(strippoint)
 
             if linkrev < minlink:
                 brokenrevs.add(strippoint)
             else:
                 futurelargelinkrevs.remove(linkrev)
 
             for p in self.parentrevs(strippoint):
                 if p != nullrev:
                     plinkrev = self.linkrev(p)
                     heads[p] = plinkrev
                     if plinkrev >= minlink:
                         futurelargelinkrevs.add(plinkrev)
 
         return strippoint, brokenrevs
 
     def strip(self, minlink, transaction):
         if not len(self):
             return
 
         rev, _ignored = self.getstrippoint(minlink)
         if rev == len(self):
             return
 
         # Purge index data starting at the requested revision.
         self._indexdata[rev:] = []
         self._reflectindexupdate()
 
+def issimplestorefile(f, kind, st):
+    if kind != stat.S_IFREG:
+        return False
+
+    if store.isrevlog(f, kind, st):
+        return False
+
+    # Ignore transaction undo files.
+    if f.startswith('undo.'):
+        return False
+
+    # Otherwise assume it belongs to the simple store.
+    return True
+
+class simplestore(store.encodedstore):
+    def datafiles(self):
+        for x in super(simplestore, self).datafiles():
+            yield x
+
+        # Supplement with non-revlog files.
+        extrafiles = self._walk('data', True, filefilter=issimplestorefile)
+
+        for unencoded, encoded, size in extrafiles:
+            try:
+                unencoded = store.decodefilename(unencoded)
+            except KeyError:
+                unencoded = None
+
+            yield unencoded, encoded, size
+
 def reposetup(ui, repo):
     if not repo.local():
         return
 
     if isinstance(repo, bundlerepo.bundlerepository):
         raise error.Abort(_('cannot use simple store with bundlerepo'))
 
     class simplestorerepo(repo.__class__):
         def file(self, f):
             return filestorage(self.svfs, f)
 
     repo.__class__ = simplestorerepo
+
+def featuresetup(ui, supported):
+    supported.add(REQUIREMENT)
+
+def newreporequirements(orig, repo):
+    """Modifies default requirements for new repos to use the simple store."""
+    requirements = orig(repo)
+
+    # These requirements are only used to affect creation of the store
+    # object. We have our own store. So we can remove them.
+    # TODO do this once we feel like taking the test hit.
+    #if 'fncache' in requirements:
+    #    requirements.remove('fncache')
+    #if 'dotencode' in requirements:
+    #    requirements.remove('dotencode')
+
+    requirements.add(REQUIREMENT)
+
+    return requirements
+
+def makestore(orig, requirements, path, vfstype):
+    if REQUIREMENT not in requirements:
+        return orig(requirements, path, vfstype)
+
+    return simplestore(path, vfstype)
+
+def extsetup(ui):
+    localrepo.featuresetupfuncs.add(featuresetup)
+
+    extensions.wrapfunction(localrepo, 'newreporequirements',
+                            newreporequirements)
+    extensions.wrapfunction(store, 'store', makestore)

tests/test-clone.t

@@ -1,1295 +1,1293 b''
 #testcases sshv1 sshv2
 
 #if sshv2
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > sshpeer.advertise-v2 = true
   > sshserver.support-v2 = true
   > EOF
 #endif
 
 Prepare repo a:
 
   $ hg init a
   $ cd a
   $ echo a > a
   $ hg add a
   $ hg commit -m test
   $ echo first line > b
   $ hg add b
 
 Create a non-inlined filelog:
 
   $ $PYTHON -c 'open("data1", "wb").write(b"".join(b"%d\n" % x for x in range(10000)))'
   $ for j in 0 1 2 3 4 5 6 7 8 9; do
   >   cat data1 >> b
   >   hg commit -m test
   > done
 
 List files in store/data (should show a 'b.d'):
 
 #if reporevlogstore
   $ for i in .hg/store/data/*; do
   >   echo $i
   > done
   .hg/store/data/a.i
   .hg/store/data/b.d
   .hg/store/data/b.i
 #endif
 
 Trigger branchcache creation:
 
   $ hg branches
   default                       10:a7949464abda
   $ ls .hg/cache
   branch2-served
   checkisexec (execbit !)
   checklink (symlink !)
   checklink-target (symlink !)
   checknoexec (execbit !)
   rbc-names-v1
   rbc-revs-v1
 
 Default operation:
 
   $ hg clone . ../b
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../b
 
 Ensure branchcache got copied over:
 
   $ ls .hg/cache
   branch2-served
   checkisexec (execbit !)
   checklink (symlink !)
   checklink-target (symlink !)
   rbc-names-v1
   rbc-revs-v1
 
   $ cat a
   a
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 11 changesets, 11 total revisions
 
 Invalid dest '' must abort:
 
   $ hg clone . ''
   abort: empty destination path is not valid
   [255]
 
 No update, with debug option:
 
 #if hardlink
   $ hg --debug clone -U . ../c --config progress.debug=true
   linking: 1
   linking: 2
   linking: 3
   linking: 4
   linking: 5
   linking: 6
   linking: 7
   linking: 8
   linked 8 files (reporevlogstore !)
   linking: 9 (reposimplestore !)
   linking: 10 (reposimplestore !)
   linking: 11 (reposimplestore !)
   linking: 12 (reposimplestore !)
   linking: 13 (reposimplestore !)
   linking: 14 (reposimplestore !)
   linking: 15 (reposimplestore !)
   linking: 16 (reposimplestore !)
   linking: 17 (reposimplestore !)
-  linking: 18 (reposimplestore !)
-  linked 18 files (reposimplestore !)
+  linked 17 files (reposimplestore !)
 #else
   $ hg --debug clone -U . ../c --config progress.debug=true
   linking: 1
   copying: 2
   copying: 3
   copying: 4
   copying: 5
   copying: 6
   copying: 7
   copying: 8
   copied 8 files (reporevlogstore !)
   copying: 9 (reposimplestore !)
   copying: 10 (reposimplestore !)
   copying: 11 (reposimplestore !)
   copying: 12 (reposimplestore !)
   copying: 13 (reposimplestore !)
   copying: 14 (reposimplestore !)
   copying: 15 (reposimplestore !)
   copying: 16 (reposimplestore !)
   copying: 17 (reposimplestore !)
-  copying: 18 (reposimplestore !)
-  copied 18 files (reposimplestore !)
+  copied 17 files (reposimplestore !)
 #endif
   $ cd ../c
 
 Ensure branchcache got copied over:
 
   $ ls .hg/cache
   branch2-served
   rbc-names-v1
   rbc-revs-v1
 
   $ cat a 2>/dev/null || echo "a not present"
   a not present
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 11 changesets, 11 total revisions
 
 Default destination:
 
   $ mkdir ../d
   $ cd ../d
   $ hg clone ../a
   destination directory: a
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd a
   $ hg cat a
   a
   $ cd ../..
 
 Check that we drop the 'file:' from the path before writing the .hgrc:
 
   $ hg clone file:a e
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ grep 'file:' e/.hg/hgrc
   [1]
 
 Check that path aliases are expanded:
 
   $ hg clone -q -U --config 'paths.foobar=a#0' foobar f
   $ hg -R f showconfig paths.default
   $TESTTMP/a#0
 
 Use --pull:
 
   $ hg clone --pull a g
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 11 changesets with 11 changes to 2 files
   new changesets acb14030fe0a:a7949464abda
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R g verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 11 changesets, 11 total revisions
 
 Invalid dest '' with --pull must abort (issue2528):
 
   $ hg clone --pull a ''
   abort: empty destination path is not valid
   [255]
 
 Clone to '.':
 
   $ mkdir h
   $ cd h
   $ hg clone ../a .
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
 
 
 *** Tests for option -u ***
 
 Adding some more history to repo a:
 
   $ cd a
   $ hg tag ref1
   $ echo the quick brown fox >a
   $ hg ci -m "hacked default"
   $ hg up ref1
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch stable
   marked working directory as branch stable
   (branches are permanent and global, did you want a bookmark?)
   $ echo some text >a
   $ hg ci -m "starting branch stable"
   $ hg tag ref2
   $ echo some more text >a
   $ hg ci -m "another change for branch stable"
   $ hg up ref2
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg parents
   changeset:   13:e8ece76546a6
   branch:      stable
   tag:         ref2
   parent:      10:a7949464abda
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     starting branch stable
   
 
 Repo a has two heads:
 
   $ hg heads
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
   $ cd ..
 
 
 Testing --noupdate with --updaterev (must abort):
 
   $ hg clone --noupdate --updaterev 1 a ua
   abort: cannot specify both --noupdate and --updaterev
   [255]
 
 
 Testing clone -u:
 
   $ hg clone -u . a ua
   updating to branch stable
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has both heads:
 
   $ hg -R ua heads
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
 Same revision checked out in repo a and ua:
 
   $ hg -R a parents --template "{node|short}\n"
   e8ece76546a6
   $ hg -R ua parents --template "{node|short}\n"
   e8ece76546a6
 
   $ rm -r ua
 
 
 Testing clone --pull -u:
 
   $ hg clone --pull -u . a ua
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 16 changesets with 16 changes to 3 files (+1 heads)
   new changesets acb14030fe0a:0aae7cf88f0d
   updating to branch stable
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has both heads:
 
   $ hg -R ua heads
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
 Same revision checked out in repo a and ua:
 
   $ hg -R a parents --template "{node|short}\n"
   e8ece76546a6
   $ hg -R ua parents --template "{node|short}\n"
   e8ece76546a6
 
   $ rm -r ua
 
 
 Testing clone -u <branch>:
 
   $ hg clone -u stable a ua
   updating to branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has both heads:
 
   $ hg -R ua heads
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
 Branch 'stable' is checked out:
 
   $ hg -R ua parents
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
 
   $ rm -r ua
 
 
 Testing default checkout:
 
   $ hg clone a ua
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has both heads:
 
   $ hg -R ua heads
   changeset:   15:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
 Branch 'default' is checked out:
 
   $ hg -R ua parents
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 Test clone with a branch named "@" (issue3677)
 
   $ hg -R ua branch @
   marked working directory as branch @
   $ hg -R ua commit -m 'created branch @'
   $ hg clone ua atbranch
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R atbranch heads
   changeset:   16:798b6d97153e
   branch:      @
   tag:         tip
   parent:      12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     created branch @
   
   changeset:   15:0aae7cf88f0d
   branch:      stable
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
   $ hg -R atbranch parents
   changeset:   12:f21241060d6a
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     hacked default
   
 
   $ rm -r ua atbranch
 
 
 Testing #<branch>:
 
   $ hg clone -u . a#stable ua
   adding changesets
   adding manifests
   adding file changes
   added 14 changesets with 14 changes to 3 files
   new changesets acb14030fe0a:0aae7cf88f0d
   updating to branch stable
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has branch 'stable' and 'default' (was changed in fd511e9eeea6):
 
   $ hg -R ua heads
   changeset:   13:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   10:a7949464abda
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test
   
 
 Same revision checked out in repo a and ua:
 
   $ hg -R a parents --template "{node|short}\n"
   e8ece76546a6
   $ hg -R ua parents --template "{node|short}\n"
   e8ece76546a6
 
   $ rm -r ua
 
 
 Testing -u -r <branch>:
 
   $ hg clone -u . -r stable a ua
   adding changesets
   adding manifests
   adding file changes
   added 14 changesets with 14 changes to 3 files
   new changesets acb14030fe0a:0aae7cf88f0d
   updating to branch stable
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has branch 'stable' and 'default' (was changed in fd511e9eeea6):
 
   $ hg -R ua heads
   changeset:   13:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   10:a7949464abda
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test
   
 
 Same revision checked out in repo a and ua:
 
   $ hg -R a parents --template "{node|short}\n"
   e8ece76546a6
   $ hg -R ua parents --template "{node|short}\n"
   e8ece76546a6
 
   $ rm -r ua
 
 
 Testing -r <branch>:
 
   $ hg clone -r stable a ua
   adding changesets
   adding manifests
   adding file changes
   added 14 changesets with 14 changes to 3 files
   new changesets acb14030fe0a:0aae7cf88f0d
   updating to branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Repo ua has branch 'stable' and 'default' (was changed in fd511e9eeea6):
 
   $ hg -R ua heads
   changeset:   13:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
   changeset:   10:a7949464abda
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     test
   
 
 Branch 'stable' is checked out:
 
   $ hg -R ua parents
   changeset:   13:0aae7cf88f0d
   branch:      stable
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     another change for branch stable
   
 
   $ rm -r ua
 
 
 Issue2267: Error in 1.6 hg.py: TypeError: 'NoneType' object is not
 iterable in addbranchrevs()
 
   $ cat <<EOF > simpleclone.py
   > from mercurial import ui, hg
   > myui = ui.ui.load()
   > repo = hg.repository(myui, 'a')
   > hg.clone(myui, {}, repo, dest="ua")
   > EOF
 
   $ $PYTHON simpleclone.py
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ rm -r ua
 
   $ cat <<EOF > branchclone.py
   > from mercurial import ui, hg, extensions
   > myui = ui.ui.load()
   > extensions.loadall(myui)
   > repo = hg.repository(myui, 'a')
   > hg.clone(myui, {}, repo, dest="ua", branch=["stable",])
   > EOF
 
   $ $PYTHON branchclone.py
   adding changesets
   adding manifests
   adding file changes
   added 14 changesets with 14 changes to 3 files
   new changesets acb14030fe0a:0aae7cf88f0d
   updating to branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm -r ua
 
 
 Test clone with special '@' bookmark:
   $ cd a
   $ hg bookmark -r a7949464abda @  # branch point of stable from default
   $ hg clone . ../i
   updating to bookmark @
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -i ../i
   a7949464abda
   $ rm -r ../i
 
   $ hg bookmark -f -r stable @
   $ hg bookmarks
      @                         15:0aae7cf88f0d
   $ hg clone . ../i
   updating to bookmark @ on branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id -i ../i
   0aae7cf88f0d
   $ cd "$TESTTMP"
 
 
 Testing failures:
 
   $ mkdir fail
   $ cd fail
 
 No local source
 
   $ hg clone a b
   abort: repository a not found!
   [255]
 
 No remote source
 
 #if windows
   $ hg clone http://$LOCALIP:3121/a b
   abort: error: * (glob)
   [255]
 #else
   $ hg clone http://$LOCALIP:3121/a b
   abort: error: *refused* (glob)
   [255]
 #endif
   $ rm -rf b # work around bug with http clone
 
 
 #if unix-permissions no-root
 
 Inaccessible source
 
   $ mkdir a
   $ chmod 000 a
   $ hg clone a b
   abort: repository a not found!
   [255]
 
 Inaccessible destination
 
   $ hg init b
   $ cd b
   $ hg clone . ../a
   abort: Permission denied: '../a'
   [255]
   $ cd ..
   $ chmod 700 a
   $ rm -r a b
 
 #endif
 
 
 #if fifo
 
 Source of wrong type
 
   $ mkfifo a
   $ hg clone a b
   abort: repository a not found!
   [255]
   $ rm a
 
 #endif
 
 Default destination, same directory
 
   $ hg init q
   $ hg clone q
   destination directory: q
   abort: destination 'q' is not empty
   [255]
 
 destination directory not empty
 
   $ mkdir a
   $ echo stuff > a/a
   $ hg clone q a
   abort: destination 'a' is not empty
   [255]
 
 
 #if unix-permissions no-root
 
 leave existing directory in place after clone failure
 
   $ hg init c
   $ cd c
   $ echo c > c
   $ hg commit -A -m test
   adding c
   $ chmod -rx .hg/store/data
   $ cd ..
   $ mkdir d
   $ hg clone c d 2> err
   [255]
   $ test -d d
   $ test -d d/.hg
   [1]
 
 re-enable perm to allow deletion
 
   $ chmod +rx c/.hg/store/data
 
 #endif
 
   $ cd ..
 
 Test clone from the repository in (emulated) revlog format 0 (issue4203):
 
   $ mkdir issue4203
   $ mkdir -p src/.hg
   $ echo foo > src/foo
   $ hg -R src add src/foo
   $ hg -R src commit -m '#0'
   $ hg -R src log -q
   0:e1bab28bca43
   $ hg clone -U -q src dst
   $ hg -R dst log -q
   0:e1bab28bca43
 
 Create repositories to test auto sharing functionality
 
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > share=
   > EOF
 
   $ hg init empty
   $ hg init source1a
   $ cd source1a
   $ echo initial1 > foo
   $ hg -q commit -A -m initial
   $ echo second > foo
   $ hg commit -m second
   $ cd ..
 
   $ hg init filteredrev0
   $ cd filteredrev0
   $ cat >> .hg/hgrc << EOF
   > [experimental]
   > evolution.createmarkers=True
   > EOF
   $ echo initial1 > foo
   $ hg -q commit -A -m initial0
   $ hg -q up -r null
   $ echo initial2 > foo
   $ hg -q commit -A -m initial1
   $ hg debugobsolete c05d5c47a5cf81401869999f3d05f7d699d2b29a e082c1832e09a7d1e78b7fd49a592d372de854c8
   obsoleted 1 changesets
   $ cd ..
 
   $ hg -q clone --pull source1a source1b
   $ cd source1a
   $ hg bookmark bookA
   $ echo 1a > foo
   $ hg commit -m 1a
   $ cd ../source1b
   $ hg -q up -r 0
   $ echo head1 > foo
   $ hg commit -m head1
   created new head
   $ hg bookmark head1
   $ hg -q up -r 0
   $ echo head2 > foo
   $ hg commit -m head2
   created new head
   $ hg bookmark head2
   $ hg -q up -r 0
   $ hg branch branch1
   marked working directory as branch branch1
   (branches are permanent and global, did you want a bookmark?)
   $ echo branch1 > foo
   $ hg commit -m branch1
   $ hg -q up -r 0
   $ hg branch branch2
   marked working directory as branch branch2
   $ echo branch2 > foo
   $ hg commit -m branch2
   $ cd ..
   $ hg init source2
   $ cd source2
   $ echo initial2 > foo
   $ hg -q commit -A -m initial2
   $ echo second > foo
   $ hg commit -m second
   $ cd ..
 
 Clone with auto share from an empty repo should not result in share
 
   $ mkdir share
   $ hg --config share.pool=share clone empty share-empty
   (not using pooled storage: remote appears to be empty)
   updating to branch default
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ ls share
   $ test -d share-empty/.hg/store
   $ test -f share-empty/.hg/sharedpath
   [1]
 
 Clone with auto share from a repo with filtered revision 0 should not result in share
 
   $ hg --config share.pool=share clone filteredrev0 share-filtered
   (not using pooled storage: unable to resolve identity of remote)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets e082c1832e09
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Clone from repo with content should result in shared store being created
 
   $ hg --config share.pool=share clone source1a share-dest1a
   (sharing from new pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets b5f04eac9d8f:e5bfe23c0b47
   searching for changes
   no changes found
   adding remote bookmark bookA
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 The shared repo should have been created
 
   $ ls share
   b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1
 
 The destination should point to it
 
   $ cat share-dest1a/.hg/sharedpath; echo
   $TESTTMP/share/b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1/.hg
 
 The destination should have bookmarks
 
   $ hg -R share-dest1a bookmarks
      bookA                     2:e5bfe23c0b47
 
 The default path should be the remote, not the share
 
   $ hg -R share-dest1a config paths.default
   $TESTTMP/source1a
 
 Clone with existing share dir should result in pull + share
 
   $ hg --config share.pool=share clone source1b share-dest1b
   (sharing from existing pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 4 changes to 1 files (+4 heads)
   adding remote bookmark head1
   adding remote bookmark head2
   new changesets 4a8dc1ab4c13:6bacf4683960
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls share
   b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1
 
   $ cat share-dest1b/.hg/sharedpath; echo
   $TESTTMP/share/b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1/.hg
 
 We only get bookmarks from the remote, not everything in the share
 
   $ hg -R share-dest1b bookmarks
      head1                     3:4a8dc1ab4c13
      head2                     4:99f71071f117
 
 Default path should be source, not share.
 
   $ hg -R share-dest1b config paths.default
   $TESTTMP/source1b
 
 Checked out revision should be head of default branch
 
   $ hg -R share-dest1b log -r .
   changeset:   4:99f71071f117
   bookmark:    head2
   parent:      0:b5f04eac9d8f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     head2
   
 
 Clone from unrelated repo should result in new share
 
   $ hg --config share.pool=share clone source2 share-dest2
   (sharing from new pooled repository 22aeff664783fd44c6d9b435618173c118c3448e)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   new changesets 22aeff664783:63cf6c3dba4a
   searching for changes
   no changes found
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls share
   22aeff664783fd44c6d9b435618173c118c3448e
   b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1
 
 remote naming mode works as advertised
 
   $ hg --config share.pool=shareremote --config share.poolnaming=remote clone source1a share-remote1a
   (sharing from new pooled repository 195bb1fcdb595c14a6c13e0269129ed78f6debde)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets b5f04eac9d8f:e5bfe23c0b47
   searching for changes
   no changes found
   adding remote bookmark bookA
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls shareremote
   195bb1fcdb595c14a6c13e0269129ed78f6debde
 
   $ hg --config share.pool=shareremote --config share.poolnaming=remote clone source1b share-remote1b
   (sharing from new pooled repository c0d4f83847ca2a873741feb7048a45085fd47c46)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 6 changes to 1 files (+4 heads)
   new changesets b5f04eac9d8f:6bacf4683960
   searching for changes
   no changes found
   adding remote bookmark head1
   adding remote bookmark head2
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ ls shareremote
   195bb1fcdb595c14a6c13e0269129ed78f6debde
   c0d4f83847ca2a873741feb7048a45085fd47c46
 
 request to clone a single revision is respected in sharing mode
 
   $ hg --config share.pool=sharerevs clone -r 4a8dc1ab4c13 source1b share-1arev
   (sharing from new pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   new changesets b5f04eac9d8f:4a8dc1ab4c13
   no changes found
   adding remote bookmark head1
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R share-1arev log -G
   @  changeset:   1:4a8dc1ab4c13
   |  bookmark:    head1
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     head1
   |
   o  changeset:   0:b5f04eac9d8f
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     initial
   
 
 making another clone should only pull down requested rev
 
   $ hg --config share.pool=sharerevs clone -r 99f71071f117 source1b share-1brev
   (sharing from existing pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   adding remote bookmark head1
   adding remote bookmark head2
   new changesets 99f71071f117
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R share-1brev log -G
   @  changeset:   2:99f71071f117
   |  bookmark:    head2
   |  tag:         tip
   |  parent:      0:b5f04eac9d8f
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     head2
   |
   | o  changeset:   1:4a8dc1ab4c13
   |/   bookmark:    head1
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     head1
   |
   o  changeset:   0:b5f04eac9d8f
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     initial
   
 
 Request to clone a single branch is respected in sharing mode
 
   $ hg --config share.pool=sharebranch clone -b branch1 source1b share-1bbranch1
   (sharing from new pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 1 files
   new changesets b5f04eac9d8f:5f92a6c1a1b1
   no changes found
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R share-1bbranch1 log -G
   o  changeset:   1:5f92a6c1a1b1
   |  branch:      branch1
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     branch1
   |
   @  changeset:   0:b5f04eac9d8f
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     initial
   
 
   $ hg --config share.pool=sharebranch clone -b branch2 source1b share-1bbranch2
   (sharing from existing pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets 6bacf4683960
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg -R share-1bbranch2 log -G
   o  changeset:   2:6bacf4683960
   |  branch:      branch2
   |  tag:         tip
   |  parent:      0:b5f04eac9d8f
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     branch2
   |
   | o  changeset:   1:5f92a6c1a1b1
   |/   branch:      branch1
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     branch1
   |
   @  changeset:   0:b5f04eac9d8f
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     initial
   
 
 -U is respected in share clone mode
 
   $ hg --config share.pool=share clone -U source1a share-1anowc
   (sharing from existing pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   searching for changes
   no changes found
   adding remote bookmark bookA
 
   $ ls share-1anowc
 
 Test that auto sharing doesn't cause failure of "hg clone local remote"
 
   $ cd $TESTTMP
   $ hg -R a id -r 0
   acb14030fe0a
   $ hg id -R remote -r 0
   abort: repository remote not found!
   [255]
   $ hg --config share.pool=share -q clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" a ssh://user@dummy/remote
   $ hg -R remote id -r 0
   acb14030fe0a
 
 Cloning into pooled storage doesn't race (issue5104)
 
   $ HGPOSTLOCKDELAY=2.0 hg --config share.pool=racepool --config extensions.lockdelay=$TESTDIR/lockdelay.py clone source1a share-destrace1 > race1.log 2>&1 &
   $ HGPRELOCKDELAY=1.0 hg --config share.pool=racepool --config extensions.lockdelay=$TESTDIR/lockdelay.py clone source1a share-destrace2  > race2.log 2>&1
   $ wait
 
   $ hg -R share-destrace1 log -r tip
   changeset:   2:e5bfe23c0b47
   bookmark:    bookA
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1a
   
 
   $ hg -R share-destrace2 log -r tip
   changeset:   2:e5bfe23c0b47
   bookmark:    bookA
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     1a
   
 One repo should be new, the other should be shared from the pool. We
 don't care which is which, so we just make sure we always print the
 one containing "new pooled" first, then one one containing "existing
 pooled".
 
   $ (grep 'new pooled' race1.log > /dev/null && cat race1.log || cat race2.log) | grep -v lock
   (sharing from new pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets b5f04eac9d8f:e5bfe23c0b47
   searching for changes
   no changes found
   adding remote bookmark bookA
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ (grep 'existing pooled' race1.log > /dev/null && cat race1.log || cat race2.log) | grep -v lock
   (sharing from existing pooled repository b5f04eac9d8f7a6a9fcb070243cccea7dc5ea0c1)
   searching for changes
   no changes found
   adding remote bookmark bookA
   updating working directory
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 SEC: check for unsafe ssh url
 
   $ cat >> $HGRCPATH << EOF
   > [ui]
   > ssh = sh -c "read l; read l; read l"
   > EOF
 
   $ hg clone 'ssh://-oProxyCommand=touch${IFS}owned/path'
   abort: potentially unsafe url: 'ssh://-oProxyCommand=touch${IFS}owned/path'
   [255]
   $ hg clone 'ssh://%2DoProxyCommand=touch${IFS}owned/path'
   abort: potentially unsafe url: 'ssh://-oProxyCommand=touch${IFS}owned/path'
   [255]
   $ hg clone 'ssh://fakehost|touch%20owned/path'
   abort: no suitable response from remote hg!
   [255]
   $ hg clone 'ssh://fakehost%7Ctouch%20owned/path'
   abort: no suitable response from remote hg!
   [255]
 
   $ hg clone 'ssh://-oProxyCommand=touch [e-mail]/nonexistent/path'
   abort: potentially unsafe url: 'ssh://-oProxyCommand=touch owned [e-mail]/nonexistent/path'
   [255]
 
 #if windows
   $ hg clone "ssh://%26touch%20owned%20/" --debug
   running sh -c "read l; read l; read l" "&touch owned " "hg -R . serve --stdio"
   sending upgrade request: * proto=exp-ssh-v2-0001 (glob) (sshv2 !)
   sending hello command
   sending between command
   abort: no suitable response from remote hg!
   [255]
   $ hg clone "ssh://example.com:%26touch%20owned%20/" --debug
   running sh -c "read l; read l; read l" -p "&touch owned " example.com "hg -R . serve --stdio"
   sending upgrade request: * proto=exp-ssh-v2-0001 (glob) (sshv2 !)
   sending hello command
   sending between command
   abort: no suitable response from remote hg!
   [255]
 #else
   $ hg clone "ssh://%3btouch%20owned%20/" --debug
   running sh -c "read l; read l; read l" ';touch owned ' 'hg -R . serve --stdio'
   sending upgrade request: * proto=exp-ssh-v2-0001 (glob) (sshv2 !)
   sending hello command
   sending between command
   abort: no suitable response from remote hg!
   [255]
   $ hg clone "ssh://example.com:%3btouch%20owned%20/" --debug
   running sh -c "read l; read l; read l" -p ';touch owned ' example.com 'hg -R . serve --stdio'
   sending upgrade request: * proto=exp-ssh-v2-0001 (glob) (sshv2 !)
   sending hello command
   sending between command
   abort: no suitable response from remote hg!
   [255]
 #endif
 
   $ hg clone "ssh://v-alid.example.com/" --debug
   running sh -c "read l; read l; read l" v-alid\.example\.com ['"]hg -R \. serve --stdio['"] (re)
   sending upgrade request: * proto=exp-ssh-v2-0001 (glob) (sshv2 !)
   sending hello command
   sending between command
   abort: no suitable response from remote hg!
   [255]
 
 We should not have created a file named owned - if it exists, the
 attack succeeded.
   $ if test -f owned; then echo 'you got owned'; fi
 
 Cloning without fsmonitor enabled does not print a warning for small repos
 
   $ hg clone a fsmonitor-default
   updating to bookmark @ on branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Lower the warning threshold to simulate a large repo
 
   $ cat >> $HGRCPATH << EOF
   > [fsmonitor]
   > warn_update_file_count = 2
   > EOF
 
 We should see a warning about no fsmonitor on supported platforms
 
 #if linuxormacos no-fsmonitor
   $ hg clone a nofsmonitor
   updating to bookmark @ on branch stable
   (warning: large working directory being used without fsmonitor enabled; enable fsmonitor to improve performance; see "hg help -e fsmonitor")
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #else
   $ hg clone a nofsmonitor
   updating to bookmark @ on branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
 We should not see warning about fsmonitor when it is enabled
 
 #if fsmonitor
   $ hg clone a fsmonitor-enabled
   updating to bookmark @ on branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
 We can disable the fsmonitor warning
 
   $ hg --config fsmonitor.warn_when_unused=false clone a fsmonitor-disable-warning
   updating to bookmark @ on branch stable
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Loaded fsmonitor but disabled in config should still print warning
 
 #if linuxormacos fsmonitor
   $ hg --config fsmonitor.mode=off clone a fsmonitor-mode-off
   updating to bookmark @ on branch stable
   (warning: large working directory being used without fsmonitor enabled; enable fsmonitor to improve performance; see "hg help -e fsmonitor") (fsmonitor !)
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
 Warning not printed if working directory isn't empty
 
   $ hg -q clone a fsmonitor-update
   (warning: large working directory being used without fsmonitor enabled; enable fsmonitor to improve performance; see "hg help -e fsmonitor") (?)
   $ cd fsmonitor-update
   $ hg up acb14030fe0a
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   (leaving bookmark @)
   $ hg up cf0fe1914066
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 `hg update` from null revision also prints
 
   $ hg up null
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
 #if linuxormacos no-fsmonitor
   $ hg up cf0fe1914066
   (warning: large working directory being used without fsmonitor enabled; enable fsmonitor to improve performance; see "hg help -e fsmonitor")
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #else
   $ hg up cf0fe1914066
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #endif
 
   $ cd ..
 

tests/test-convert.t

@@ -1,622 +1,618 b''
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > convert=
   > [convert]
   > hg.saverev=False
   > EOF
   $ hg help convert
   hg convert [OPTION]... SOURCE [DEST [REVMAP]]
   
   convert a foreign SCM repository to a Mercurial one.
   
       Accepted source formats [identifiers]:
   
       - Mercurial [hg]
       - CVS [cvs]
       - Darcs [darcs]
       - git [git]
       - Subversion [svn]
       - Monotone [mtn]
       - GNU Arch [gnuarch]
       - Bazaar [bzr]
       - Perforce [p4]
   
       Accepted destination formats [identifiers]:
   
       - Mercurial [hg]
       - Subversion [svn] (history on branches is not preserved)
   
       If no revision is given, all revisions will be converted. Otherwise,
       convert will only import up to the named revision (given in a format
       understood by the source).
   
       If no destination directory name is specified, it defaults to the basename
       of the source with "-hg" appended. If the destination repository doesn't
       exist, it will be created.
   
       By default, all sources except Mercurial will use --branchsort. Mercurial
       uses --sourcesort to preserve original revision numbers order. Sort modes
       have the following effects:
   
       --branchsort  convert from parent to child revision when possible, which
                     means branches are usually converted one after the other.
                     It generates more compact repositories.
       --datesort    sort revisions by date. Converted repositories have good-
                     looking changelogs but are often an order of magnitude
                     larger than the same ones generated by --branchsort.
       --sourcesort  try to preserve source revisions order, only supported by
                     Mercurial sources.
       --closesort   try to move closed revisions as close as possible to parent
                     branches, only supported by Mercurial sources.
   
       If "REVMAP" isn't given, it will be put in a default location
       ("<dest>/.hg/shamap" by default). The "REVMAP" is a simple text file that
       maps each source commit ID to the destination ID for that revision, like
       so:
   
         <source ID> <destination ID>
   
       If the file doesn't exist, it's automatically created. It's updated on
       each commit copied, so 'hg convert' can be interrupted and can be run
       repeatedly to copy new commits.
   
       The authormap is a simple text file that maps each source commit author to
       a destination commit author. It is handy for source SCMs that use unix
       logins to identify authors (e.g.: CVS). One line per author mapping and
       the line format is:
   
         source author = destination author
   
       Empty lines and lines starting with a "#" are ignored.
   
       The filemap is a file that allows filtering and remapping of files and
       directories. Each line can contain one of the following directives:
   
         include path/to/file-or-dir
   
         exclude path/to/file-or-dir
   
         rename path/to/source path/to/destination
   
       Comment lines start with "#". A specified path matches if it equals the
       full relative name of a file or one of its parent directories. The
       "include" or "exclude" directive with the longest matching path applies,
       so line order does not matter.
   
       The "include" directive causes a file, or all files under a directory, to
       be included in the destination repository. The default if there are no
       "include" statements is to include everything. If there are any "include"
       statements, nothing else is included. The "exclude" directive causes files
       or directories to be omitted. The "rename" directive renames a file or
       directory if it is converted. To rename from a subdirectory into the root
       of the repository, use "." as the path to rename to.
   
       "--full" will make sure the converted changesets contain exactly the right
       files with the right content. It will make a full conversion of all files,
       not just the ones that have changed. Files that already are correct will
       not be changed. This can be used to apply filemap changes when converting
       incrementally. This is currently only supported for Mercurial and
       Subversion.
   
       The splicemap is a file that allows insertion of synthetic history,
       letting you specify the parents of a revision. This is useful if you want
       to e.g. give a Subversion merge two parents, or graft two disconnected
       series of history together. Each entry contains a key, followed by a
       space, followed by one or two comma-separated values:
   
         key parent1, parent2
   
       The key is the revision ID in the source revision control system whose
       parents should be modified (same format as a key in .hg/shamap). The
       values are the revision IDs (in either the source or destination revision
       control system) that should be used as the new parents for that node. For
       example, if you have merged "release-1.0" into "trunk", then you should
       specify the revision on "trunk" as the first parent and the one on the
       "release-1.0" branch as the second.
   
       The branchmap is a file that allows you to rename a branch when it is
       being brought in from whatever external repository. When used in
       conjunction with a splicemap, it allows for a powerful combination to help
       fix even the most badly mismanaged repositories and turn them into nicely
       structured Mercurial repositories. The branchmap contains lines of the
       form:
   
         original_branch_name new_branch_name
   
       where "original_branch_name" is the name of the branch in the source
       repository, and "new_branch_name" is the name of the branch is the
       destination repository. No whitespace is allowed in the new branch name.
       This can be used to (for instance) move code in one repository from
       "default" to a named branch.
   
       Mercurial Source
       ################
   
       The Mercurial source recognizes the following configuration options, which
       you can set on the command line with "--config":
   
       convert.hg.ignoreerrors
                     ignore integrity errors when reading. Use it to fix
                     Mercurial repositories with missing revlogs, by converting
                     from and to Mercurial. Default is False.
       convert.hg.saverev
                     store original revision ID in changeset (forces target IDs
                     to change). It takes a boolean argument and defaults to
                     False.
       convert.hg.startrev
                     specify the initial Mercurial revision. The default is 0.
       convert.hg.revs
                     revset specifying the source revisions to convert.
   
       CVS Source
       ##########
   
       CVS source will use a sandbox (i.e. a checked-out copy) from CVS to
       indicate the starting point of what will be converted. Direct access to
       the repository files is not needed, unless of course the repository is
       ":local:". The conversion uses the top level directory in the sandbox to
       find the CVS repository, and then uses CVS rlog commands to find files to
       convert. This means that unless a filemap is given, all files under the
       starting directory will be converted, and that any directory
       reorganization in the CVS sandbox is ignored.
   
       The following options can be used with "--config":
   
       convert.cvsps.cache
                     Set to False to disable remote log caching, for testing and
                     debugging purposes. Default is True.
       convert.cvsps.fuzz
                     Specify the maximum time (in seconds) that is allowed
                     between commits with identical user and log message in a
                     single changeset. When very large files were checked in as
                     part of a changeset then the default may not be long enough.
                     The default is 60.
       convert.cvsps.logencoding
                     Specify encoding name to be used for transcoding CVS log
                     messages. Multiple encoding names can be specified as a list
                     (see 'hg help config.Syntax'), but only the first acceptable
                     encoding in the list is used per CVS log entries. This
                     transcoding is executed before cvslog hook below.
       convert.cvsps.mergeto
                     Specify a regular expression to which commit log messages
                     are matched. If a match occurs, then the conversion process
                     will insert a dummy revision merging the branch on which
                     this log message occurs to the branch indicated in the
                     regex. Default is "{{mergetobranch ([-\w]+)}}"
       convert.cvsps.mergefrom
                     Specify a regular expression to which commit log messages
                     are matched. If a match occurs, then the conversion process
                     will add the most recent revision on the branch indicated in
                     the regex as the second parent of the changeset. Default is
                     "{{mergefrombranch ([-\w]+)}}"
       convert.localtimezone
                     use local time (as determined by the TZ environment
                     variable) for changeset date/times. The default is False
                     (use UTC).
       hooks.cvslog  Specify a Python function to be called at the end of
                     gathering the CVS log. The function is passed a list with
                     the log entries, and can modify the entries in-place, or add
                     or delete them.
       hooks.cvschangesets
                     Specify a Python function to be called after the changesets
                     are calculated from the CVS log. The function is passed a
                     list with the changeset entries, and can modify the
                     changesets in-place, or add or delete them.
   
       An additional "debugcvsps" Mercurial command allows the builtin changeset
       merging code to be run without doing a conversion. Its parameters and
       output are similar to that of cvsps 2.1. Please see the command help for
       more details.
   
       Subversion Source
       #################
   
       Subversion source detects classical trunk/branches/tags layouts. By
       default, the supplied "svn://repo/path/" source URL is converted as a
       single branch. If "svn://repo/path/trunk" exists it replaces the default
       branch. If "svn://repo/path/branches" exists, its subdirectories are
       listed as possible branches. If "svn://repo/path/tags" exists, it is
       looked for tags referencing converted branches. Default "trunk",
       "branches" and "tags" values can be overridden with following options. Set
       them to paths relative to the source URL, or leave them blank to disable
       auto detection.
   
       The following options can be set with "--config":
   
       convert.svn.branches
                     specify the directory containing branches. The default is
                     "branches".
       convert.svn.tags
                     specify the directory containing tags. The default is
                     "tags".
       convert.svn.trunk
                     specify the name of the trunk branch. The default is
                     "trunk".
       convert.localtimezone
                     use local time (as determined by the TZ environment
                     variable) for changeset date/times. The default is False
                     (use UTC).
   
       Source history can be retrieved starting at a specific revision, instead
       of being integrally converted. Only single branch conversions are
       supported.
   
       convert.svn.startrev
                     specify start Subversion revision number. The default is 0.
   
       Git Source
       ##########
   
       The Git importer converts commits from all reachable branches (refs in
       refs/heads) and remotes (refs in refs/remotes) to Mercurial. Branches are
       converted to bookmarks with the same name, with the leading 'refs/heads'
       stripped. Git submodules are converted to Git subrepos in Mercurial.
   
       The following options can be set with "--config":
   
       convert.git.similarity
                     specify how similar files modified in a commit must be to be
                     imported as renames or copies, as a percentage between "0"
                     (disabled) and "100" (files must be identical). For example,
                     "90" means that a delete/add pair will be imported as a
                     rename if more than 90% of the file hasn't changed. The
                     default is "50".
       convert.git.findcopiesharder
                     while detecting copies, look at all files in the working
                     copy instead of just changed ones. This is very expensive
                     for large projects, and is only effective when
                     "convert.git.similarity" is greater than 0. The default is
                     False.
       convert.git.renamelimit
                     perform rename and copy detection up to this many changed
                     files in a commit. Increasing this will make rename and copy
                     detection more accurate but will significantly slow down
                     computation on large projects. The option is only relevant
                     if "convert.git.similarity" is greater than 0. The default
                     is "400".
       convert.git.committeractions
                     list of actions to take when processing author and committer
                     values.
   
           Git commits have separate author (who wrote the commit) and committer
           (who applied the commit) fields. Not all destinations support separate
           author and committer fields (including Mercurial). This config option
           controls what to do with these author and committer fields during
           conversion.
   
           A value of "messagedifferent" will append a "committer: ..." line to
           the commit message if the Git committer is different from the author.
           The prefix of that line can be specified using the syntax
           "messagedifferent=<prefix>". e.g. "messagedifferent=git-committer:".
           When a prefix is specified, a space will always be inserted between
           the prefix and the value.
   
           "messagealways" behaves like "messagedifferent" except it will always
           result in a "committer: ..." line being appended to the commit
           message. This value is mutually exclusive with "messagedifferent".
   
           "dropcommitter" will remove references to the committer. Only
           references to the author will remain. Actions that add references to
           the committer will have no effect when this is set.
   
           "replaceauthor" will replace the value of the author field with the
           committer. Other actions that add references to the committer will
           still take effect when this is set.
   
           The default is "messagedifferent".
   
       convert.git.extrakeys
                     list of extra keys from commit metadata to copy to the
                     destination. Some Git repositories store extra metadata in
                     commits. By default, this non-default metadata will be lost
                     during conversion. Setting this config option can retain
                     that metadata. Some built-in keys such as "parent" and
                     "branch" are not allowed to be copied.
       convert.git.remoteprefix
                     remote refs are converted as bookmarks with
                     "convert.git.remoteprefix" as a prefix followed by a /. The
                     default is 'remote'.
       convert.git.saverev
                     whether to store the original Git commit ID in the metadata
                     of the destination commit. The default is True.
       convert.git.skipsubmodules
                     does not convert root level .gitmodules files or files with
                     160000 mode indicating a submodule. Default is False.
   
       Perforce Source
       ###############
   
       The Perforce (P4) importer can be given a p4 depot path or a client
       specification as source. It will convert all files in the source to a flat
       Mercurial repository, ignoring labels, branches and integrations. Note
       that when a depot path is given you then usually should specify a target
       directory, because otherwise the target may be named "...-hg".
   
       The following options can be set with "--config":
   
       convert.p4.encoding
                     specify the encoding to use when decoding standard output of
                     the Perforce command line tool. The default is default
                     system encoding.
       convert.p4.startrev
                     specify initial Perforce revision (a Perforce changelist
                     number).
   
       Mercurial Destination
       #####################
   
       The Mercurial destination will recognize Mercurial subrepositories in the
       destination directory, and update the .hgsubstate file automatically if
       the destination subrepositories contain the <dest>/<sub>/.hg/shamap file.
       Converting a repository with subrepositories requires converting a single
       repository at a time, from the bottom up.
   
       The following options are supported:
   
       convert.hg.clonebranches
                     dispatch source branches in separate clones. The default is
                     False.
       convert.hg.tagsbranch
                     branch name for tag revisions, defaults to "default".
       convert.hg.usebranchnames
                     preserve branch names. The default is True.
       convert.hg.sourcename
                     records the given string as a 'convert_source' extra value
                     on each commit made in the target repository. The default is
                     None.
   
       All Destinations
       ################
   
       All destination types accept the following options:
   
       convert.skiptags
                     does not convert tags from the source repo to the target
                     repo. The default is False.
   
   options ([+] can be repeated):
   
    -s --source-type TYPE source repository type
    -d --dest-type TYPE   destination repository type
    -r --rev REV [+]      import up to source revision REV
    -A --authormap FILE   remap usernames using this file
       --filemap FILE     remap file names using contents of file
       --full             apply filemap changes by converting all files again
       --splicemap FILE   splice synthesized history into place
       --branchmap FILE   change branch names while converting
       --branchsort       try to sort changesets by branches
       --datesort         try to sort changesets by date
       --sourcesort       preserve source changesets order
       --closesort        try to reorder closed revisions
   
   (some details hidden, use --verbose to show complete help)
   $ hg init a
   $ cd a
   $ echo a > a
   $ hg ci -d'0 0' -Ama
   adding a
   $ hg cp a b
   $ hg ci -d'1 0' -mb
   $ hg rm a
   $ hg ci -d'2 0' -mc
   $ hg mv b a
   $ hg ci -d'3 0' -md
   $ echo a >> a
   $ hg ci -d'4 0' -me
   $ cd ..
   $ hg convert a 2>&1 | grep -v 'subversion python bindings could not be loaded'
   assuming destination a-hg
   initializing destination a-hg repository
   scanning source...
   sorting...
   converting...
   4 a
   3 b
   2 c
   1 d
   0 e
   $ hg --cwd a-hg pull ../a
   pulling from ../a
   searching for changes
   no changes found
 
 conversion to existing file should fail
 
   $ touch bogusfile
   $ hg convert a bogusfile
   initializing destination bogusfile repository
   abort: cannot create new bundle repository
   [255]
 
 #if unix-permissions no-root
 
 conversion to dir without permissions should fail
 
   $ mkdir bogusdir
   $ chmod 000 bogusdir
 
   $ hg convert a bogusdir
   abort: Permission denied: 'bogusdir'
   [255]
 
 user permissions should succeed
 
   $ chmod 700 bogusdir
   $ hg convert a bogusdir
   initializing destination bogusdir repository
   scanning source...
   sorting...
   converting...
   4 a
   3 b
   2 c
   1 d
   0 e
 
 #endif
 
 test pre and post conversion actions
 
   $ echo 'include b' > filemap
   $ hg convert --debug --filemap filemap a partialb | \
   >     grep 'run hg'
   run hg source pre-conversion action
   run hg sink pre-conversion action
   run hg sink post-conversion action
   run hg source post-conversion action
 
 converting empty dir should fail "nicely
 
   $ mkdir emptydir
 
 override $PATH to ensure p4 not visible; use $PYTHON in case we're
 running from a devel copy, not a temp installation
 
   $ PATH="$BINDIR" $PYTHON "$BINDIR"/hg convert emptydir
   assuming destination emptydir-hg
   initializing destination emptydir-hg repository
   emptydir does not look like a CVS checkout
   $TESTTMP/emptydir does not look like a Git repository
   emptydir does not look like a Subversion repository
   emptydir is not a local Mercurial repository
   emptydir does not look like a darcs repository
   emptydir does not look like a monotone repository
   emptydir does not look like a GNU Arch repository
   emptydir does not look like a Bazaar repository
   cannot find required "p4" tool
   abort: emptydir: missing or unsupported repository
   [255]
 
 convert with imaginary source type
 
   $ hg convert --source-type foo a a-foo
   initializing destination a-foo repository
   abort: foo: invalid source repository type
   [255]
 
 convert with imaginary sink type
 
   $ hg convert --dest-type foo a a-foo
   abort: foo: invalid destination repository type
   [255]
 
 testing: convert must not produce duplicate entries in fncache
 
   $ hg convert a b
   initializing destination b repository
   scanning source...
   sorting...
   converting...
   4 a
   3 b
   2 c
   1 d
   0 e
 
 contents of fncache file:
 
+#if repofncache
   $ cat b/.hg/store/fncache | sort
   data/a.i (reporevlogstore !)
   data/b.i (reporevlogstore !)
-  data/a/0f3078c2d7345d887b54f7c9dab0d91bfa57fd07 (reposimplestore !)
-  data/a/4271c3e84237016935a176b6f282fde2128458b0 (reposimplestore !)
-  data/a/b789fdd96dc2f3bd229c1dd8eedf0fc60e2b68e3 (reposimplestore !)
-  data/a/index (reposimplestore !)
-  data/b/37d9b5d994eab34eda9c16b195ace52c7b129980 (reposimplestore !)
-  data/b/index (reposimplestore !)
+#endif
 
 test bogus URL
 
   $ hg convert -q bzr+ssh://[e-mail]/baz baz
   abort: bzr+ssh://[e-mail]/baz: missing or unsupported repository
   [255]
 
 test revset converted() lookup
 
   $ hg --config convert.hg.saverev=True convert a c
   initializing destination c repository
   scanning source...
   sorting...
   converting...
   4 a
   3 b
   2 c
   1 d
   0 e
   $ echo f > c/f
   $ hg -R c ci -d'0 0' -Amf
   adding f
   created new head
   $ hg -R c log -r "converted(09d945a62ce6)"
   changeset:   1:98c3dd46a874
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b
   
   $ hg -R c log -r "converted()"
   changeset:   0:31ed57b2037c
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   changeset:   1:98c3dd46a874
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     b
   
   changeset:   2:3b9ca06ef716
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     c
   
   changeset:   3:4e0debd37cf2
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     d
   
   changeset:   4:9de3bc9349c5
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     e
   
 
 test specifying a sourcename
   $ echo g > a/g
   $ hg -R a ci -d'0 0' -Amg
   adding g
   $ hg --config convert.hg.sourcename=mysource --config convert.hg.saverev=True convert a c
   scanning source...
   sorting...
   converting...
   0 g
   $ hg -R c log -r tip --template '{extras % "{extra}\n"}'
   branch=default
   convert_revision=a3bc6100aa8ec03e00aaf271f1f50046fb432072
   convert_source=mysource
 
   $ cat > branchmap.txt << EOF
   > old branch new_branch
   > EOF
 
   $ hg -R a branch -q 'old branch'
   $ echo gg > a/g
   $ hg -R a ci -m 'branch name with spaces'
   $ hg convert --branchmap branchmap.txt a d
   initializing destination d repository
   scanning source...
   sorting...
   converting...
   6 a
   5 b
   4 c
   3 d
   2 e
   1 g
   0 branch name with spaces
 
   $ hg -R a branches
   old branch                     6:a24a66ade009
   default                        5:a3bc6100aa8e (inactive)
   $ hg -R d branches
   new_branch                     6:64ed208b732b
   default                        5:a3bc6100aa8e (inactive)

tests/test-fncache.t

@@ -1,436 +1,438 b''
+#require repofncache
+
 Init repo1:
 
   $ hg init repo1
   $ cd repo1
   $ echo "some text" > a
   $ hg add
   adding a
   $ hg ci -m first
   $ cat .hg/store/fncache | sort
   data/a.i
 
 Testing a.i/b:
 
   $ mkdir a.i
   $ echo "some other text" > a.i/b
   $ hg add
   adding a.i/b
   $ hg ci -m second
   $ cat .hg/store/fncache | sort
   data/a.i
   data/a.i.hg/b.i
 
 Testing a.i.hg/c:
 
   $ mkdir a.i.hg
   $ echo "yet another text" > a.i.hg/c
   $ hg add
   adding a.i.hg/c
   $ hg ci -m third
   $ cat .hg/store/fncache | sort
   data/a.i
   data/a.i.hg.hg/c.i
   data/a.i.hg/b.i
 
 Testing verify:
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   3 files, 3 changesets, 3 total revisions
 
   $ rm .hg/store/fncache
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
    warning: revlog 'data/a.i' not in fncache!
    warning: revlog 'data/a.i.hg/c.i' not in fncache!
    warning: revlog 'data/a.i/b.i' not in fncache!
   3 files, 3 changesets, 3 total revisions
   3 warnings encountered!
   hint: run "hg debugrebuildfncache" to recover from corrupt fncache
 
 Follow the hint to make sure it works
 
   $ hg debugrebuildfncache
   adding data/a.i
   adding data/a.i.hg/c.i
   adding data/a.i/b.i
   3 items added, 0 removed from fncache
 
   $ hg verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   3 files, 3 changesets, 3 total revisions
 
   $ cd ..
 
 Non store repo:
 
   $ hg --config format.usestore=False init foo
   $ cd foo
   $ mkdir tst.d
   $ echo foo > tst.d/foo
   $ hg ci -Amfoo
   adding tst.d/foo
   $ find .hg | sort
   .hg
   .hg/00changelog.i
   .hg/00manifest.i
   .hg/cache
   .hg/cache/branch2-served
   .hg/cache/rbc-names-v1
   .hg/cache/rbc-revs-v1
   .hg/data
   .hg/data/tst.d.hg
   .hg/data/tst.d.hg/foo.i
   .hg/dirstate
   .hg/fsmonitor.state (fsmonitor !)
   .hg/last-message.txt
   .hg/phaseroots
   .hg/requires
   .hg/undo
   .hg/undo.backup.dirstate
   .hg/undo.backupfiles
   .hg/undo.bookmarks
   .hg/undo.branch
   .hg/undo.desc
   .hg/undo.dirstate
   .hg/undo.phaseroots
   $ cd ..
 
 Non fncache repo:
 
   $ hg --config format.usefncache=False init bar
   $ cd bar
   $ mkdir tst.d
   $ echo foo > tst.d/Foo
   $ hg ci -Amfoo
   adding tst.d/Foo
   $ find .hg | sort
   .hg
   .hg/00changelog.i
   .hg/cache
   .hg/cache/branch2-served
   .hg/cache/rbc-names-v1
   .hg/cache/rbc-revs-v1
   .hg/dirstate
   .hg/fsmonitor.state (fsmonitor !)
   .hg/last-message.txt
   .hg/requires
   .hg/store
   .hg/store/00changelog.i
   .hg/store/00manifest.i
   .hg/store/data
   .hg/store/data/tst.d.hg
   .hg/store/data/tst.d.hg/_foo.i
   .hg/store/phaseroots
   .hg/store/undo
   .hg/store/undo.backupfiles
   .hg/store/undo.phaseroots
   .hg/undo.backup.dirstate
   .hg/undo.bookmarks
   .hg/undo.branch
   .hg/undo.desc
   .hg/undo.dirstate
   $ cd ..
 
 Encoding of reserved / long paths in the store
 
   $ hg init r2
   $ cd r2
   $ cat <<EOF > .hg/hgrc
   > [ui]
   > portablefilenames = ignore
   > EOF
 
   $ hg import -q --bypass - <<EOF
   > # HG changeset patch
   > # User test
   > # Date 0 0
   > # Node ID 1c7a2f7cb77be1a0def34e4c7cabc562ad98fbd7
   > # Parent  0000000000000000000000000000000000000000
   > 1
   > 
   > diff --git a/12345678/12345678/12345678/12345678/12345678/12345678/12345678/12345/xxxxxxxxx-xxxxxxxxx-xxxxxxxxx-123456789-12.3456789-12345-ABCDEFGHIJKLMNOPRSTUVWXYZ-abcdefghjiklmnopqrstuvwxyz b/12345678/12345678/12345678/12345678/12345678/12345678/12345678/12345/xxxxxxxxx-xxxxxxxxx-xxxxxxxxx-123456789-12.3456789-12345-ABCDEFGHIJKLMNOPRSTUVWXYZ-abcdefghjiklmnopqrstuvwxyz
   > new file mode 100644
   > --- /dev/null
   > +++ b/12345678/12345678/12345678/12345678/12345678/12345678/12345678/12345/xxxxxxxxx-xxxxxxxxx-xxxxxxxxx-123456789-12.3456789-12345-ABCDEFGHIJKLMNOPRSTUVWXYZ-abcdefghjiklmnopqrstuvwxyz
   > @@ -0,0 +1,1 @@
   > +foo
   > diff --git a/AUX/SECOND/X.PRN/FOURTH/FI:FTH/SIXTH/SEVENTH/EIGHTH/NINETH/TENTH/ELEVENTH/LOREMIPSUM.TXT b/AUX/SECOND/X.PRN/FOURTH/FI:FTH/SIXTH/SEVENTH/EIGHTH/NINETH/TENTH/ELEVENTH/LOREMIPSUM.TXT
   > new file mode 100644
   > --- /dev/null
   > +++ b/AUX/SECOND/X.PRN/FOURTH/FI:FTH/SIXTH/SEVENTH/EIGHTH/NINETH/TENTH/ELEVENTH/LOREMIPSUM.TXT
   > @@ -0,0 +1,1 @@
   > +foo
   > diff --git a/Project Planning/Resources/AnotherLongDirectoryName/Followedbyanother/AndAnother/AndThenAnExtremelyLongFileName.txt b/Project Planning/Resources/AnotherLongDirectoryName/Followedbyanother/AndAnother/AndThenAnExtremelyLongFileName.txt
   > new file mode 100644
   > --- /dev/null
   > +++ b/Project Planning/Resources/AnotherLongDirectoryName/Followedbyanother/AndAnother/AndThenAnExtremelyLongFileName.txt	
   > @@ -0,0 +1,1 @@
   > +foo
   > diff --git a/bla.aux/prn/PRN/lpt/com3/nul/coma/foo.NUL/normal.c b/bla.aux/prn/PRN/lpt/com3/nul/coma/foo.NUL/normal.c
   > new file mode 100644
   > --- /dev/null
   > +++ b/bla.aux/prn/PRN/lpt/com3/nul/coma/foo.NUL/normal.c
   > @@ -0,0 +1,1 @@
   > +foo
   > diff --git a/enterprise/openesbaddons/contrib-imola/corba-bc/netbeansplugin/wsdlExtension/src/main/java/META-INF/services/org.netbeans.modules.xml.wsdl.bindingsupport.spi.ExtensibilityElementTemplateProvider b/enterprise/openesbaddons/contrib-imola/corba-bc/netbeansplugin/wsdlExtension/src/main/java/META-INF/services/org.netbeans.modules.xml.wsdl.bindingsupport.spi.ExtensibilityElementTemplateProvider
   > new file mode 100644
   > --- /dev/null
   > +++ b/enterprise/openesbaddons/contrib-imola/corba-bc/netbeansplugin/wsdlExtension/src/main/java/META-INF/services/org.netbeans.modules.xml.wsdl.bindingsupport.spi.ExtensibilityElementTemplateProvider
   > @@ -0,0 +1,1 @@
   > +foo
   > EOF
 
   $ find .hg/store -name *.i  | sort
   .hg/store/00changelog.i
   .hg/store/00manifest.i
   .hg/store/data/bla.aux/pr~6e/_p_r_n/lpt/co~6d3/nu~6c/coma/foo._n_u_l/normal.c.i
   .hg/store/dh/12345678/12345678/12345678/12345678/12345678/12345678/12345678/12345/xxxxxx168e07b38e65eff86ab579afaaa8e30bfbe0f35f.i
   .hg/store/dh/au~78/second/x.prn/fourth/fi~3afth/sixth/seventh/eighth/nineth/tenth/loremia20419e358ddff1bf8751e38288aff1d7c32ec05.i
   .hg/store/dh/enterpri/openesba/contrib-/corba-bc/netbeans/wsdlexte/src/main/java/org.net7018f27961fdf338a598a40c4683429e7ffb9743.i
   .hg/store/dh/project_/resource/anotherl/followed/andanoth/andthenanextremelylongfilename0d8e1f4187c650e2f1fdca9fd90f786bc0976b6b.i
 
   $ cd ..
 
 Aborting lock does not prevent fncache writes
 
   $ cat > exceptionext.py <<EOF
   > from __future__ import absolute_import
   > import os
   > from mercurial import commands, error, extensions
   > 
   > def lockexception(orig, vfs, lockname, wait, releasefn, *args, **kwargs):
   >     def releasewrap():
   >         l.held = False # ensure __del__ is a noop
   >         raise error.Abort("forced lock failure")
   >     l = orig(vfs, lockname, wait, releasewrap, *args, **kwargs)
   >     return l
   > 
   > def reposetup(ui, repo):
   >     extensions.wrapfunction(repo, '_lock', lockexception)
   > 
   > cmdtable = {}
   > 
   > # wrap "commit" command to prevent wlock from being '__del__()'-ed
   > # at the end of dispatching (for intentional "forced lcok failure")
   > def commitwrap(orig, ui, repo, *pats, **opts):
   >     repo = repo.unfiltered() # to use replaced repo._lock certainly
   >     wlock = repo.wlock()
   >     try:
   >         return orig(ui, repo, *pats, **opts)
   >     finally:
   >         # multiple 'relase()' is needed for complete releasing wlock,
   >         # because "forced" abort at last releasing store lock
   >         # prevents wlock from being released at same 'lockmod.release()'
   >         for i in range(wlock.held):
   >             wlock.release()
   > 
   > def extsetup(ui):
   >     extensions.wrapcommand(commands.table, b"commit", commitwrap)
   > EOF
   $ extpath=`pwd`/exceptionext.py
   $ hg init fncachetxn
   $ cd fncachetxn
   $ printf "[extensions]\nexceptionext=$extpath\n" >> .hg/hgrc
   $ touch y
   $ hg ci -qAm y
   abort: forced lock failure
   [255]
   $ cat .hg/store/fncache
   data/y.i
 
 Aborting transaction prevents fncache change
 
   $ cat > ../exceptionext.py <<EOF
   > from __future__ import absolute_import
   > import os
   > from mercurial import commands, error, extensions, localrepo
   > 
   > def wrapper(orig, self, *args, **kwargs):
   >     tr = orig(self, *args, **kwargs)
   >     def fail(tr):
   >         raise error.Abort(b"forced transaction failure")
   >     # zzz prefix to ensure it sorted after store.write
   >     tr.addfinalize(b'zzz-forcefails', fail)
   >     return tr
   > 
   > def uisetup(ui):
   >     extensions.wrapfunction(
   >         localrepo.localrepository, b'transaction', wrapper)
   > 
   > cmdtable = {}
   > 
   > EOF
 
 Clean cached version
   $ rm -f "${extpath}c"
   $ rm -Rf "`dirname $extpath`/__pycache__"
 
   $ touch z
   $ hg ci -qAm z
   transaction abort!
   rollback completed
   abort: forced transaction failure
   [255]
   $ cat .hg/store/fncache
   data/y.i
 
 Aborted transactions can be recovered later
 
   $ cat > ../exceptionext.py <<EOF
   > from __future__ import absolute_import
   > import os
   > from mercurial import (
   >   commands,
   >   error,
   >   extensions,
   >   localrepo,
   >   transaction,
   > )
   > 
   > def trwrapper(orig, self, *args, **kwargs):
   >     tr = orig(self, *args, **kwargs)
   >     def fail(tr):
   >         raise error.Abort("forced transaction failure")
   >     # zzz prefix to ensure it sorted after store.write
   >     tr.addfinalize('zzz-forcefails', fail)
   >     return tr
   > 
   > def abortwrapper(orig, self, *args, **kwargs):
   >     raise error.Abort("forced transaction failure")
   > 
   > def uisetup(ui):
   >     extensions.wrapfunction(localrepo.localrepository, 'transaction',
   >                             trwrapper)
   >     extensions.wrapfunction(transaction.transaction, '_abort',
   >                             abortwrapper)
   > 
   > cmdtable = {}
   > 
   > EOF
 
 Clean cached versions
   $ rm -f "${extpath}c"
   $ rm -Rf "`dirname $extpath`/__pycache__"
 
   $ hg up -q 1
   $ touch z
   $ hg ci -qAm z 2>/dev/null
   [255]
   $ cat .hg/store/fncache | sort
   data/y.i
   data/z.i
   $ hg recover
   rolling back interrupted transaction
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   1 files, 1 changesets, 1 total revisions
   $ cat .hg/store/fncache
   data/y.i
 
   $ cd ..
 
 debugrebuildfncache does nothing unless repo has fncache requirement
 
   $ hg --config format.usefncache=false init nofncache
   $ cd nofncache
   $ hg debugrebuildfncache
   (not rebuilding fncache because repository does not support fncache)
 
   $ cd ..
 
 debugrebuildfncache works on empty repository
 
   $ hg init empty
   $ cd empty
   $ hg debugrebuildfncache
   fncache already up to date
   $ cd ..
 
 debugrebuildfncache on an up to date repository no-ops
 
   $ hg init repo
   $ cd repo
   $ echo initial > foo
   $ echo initial > .bar
   $ hg commit -A -m initial
   adding .bar
   adding foo
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i
 
   $ hg debugrebuildfncache
   fncache already up to date
 
 debugrebuildfncache restores deleted fncache file
 
   $ rm -f .hg/store/fncache
   $ hg debugrebuildfncache
   adding data/.bar.i
   adding data/foo.i
   2 items added, 0 removed from fncache
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i
 
 Rebuild after rebuild should no-op
 
   $ hg debugrebuildfncache
   fncache already up to date
 
 A single missing file should get restored, an extra file should be removed
 
   $ cat > .hg/store/fncache << EOF
   > data/foo.i
   > data/bad-entry.i
   > EOF
 
   $ hg debugrebuildfncache
   removing data/bad-entry.i
   adding data/.bar.i
   1 items added, 1 removed from fncache
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i
 
   $ cd ..
 
 Try a simple variation without dotencode to ensure fncache is ignorant of encoding
 
   $ hg --config format.dotencode=false init nodotencode
   $ cd nodotencode
   $ echo initial > foo
   $ echo initial > .bar
   $ hg commit -A -m initial
   adding .bar
   adding foo
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i
 
   $ rm .hg/store/fncache
   $ hg debugrebuildfncache
   adding data/.bar.i
   adding data/foo.i
   2 items added, 0 removed from fncache
 
   $ cat .hg/store/fncache | sort
   data/.bar.i
   data/foo.i

tests/test-hardlinks.t

@@ -1,429 +1,429 b''
 #require hardlink reporevlogstore
 
   $ cat > nlinks.py <<EOF
   > from __future__ import print_function
   > import sys
   > from mercurial import util
   > for f in sorted(sys.stdin.readlines()):
   >     f = f[:-1]
   >     print(util.nlinks(f), f)
   > EOF
 
   $ nlinksdir()
   > {
   >     find "$@" -type f | $PYTHON $TESTTMP/nlinks.py
   > }
 
 Some implementations of cp can't create hardlinks (replaces 'cp -al' on Linux):
 
   $ cat > linkcp.py <<EOF
   > from __future__ import absolute_import
   > import sys
   > from mercurial import util
   > util.copyfiles(sys.argv[1], sys.argv[2], hardlink=True)
   > EOF
 
   $ linkcp()
   > {
   >     $PYTHON $TESTTMP/linkcp.py $1 $2
   > }
 
 Prepare repo r1:
 
   $ hg init r1
   $ cd r1
 
   $ echo c1 > f1
   $ hg add f1
   $ hg ci -m0
 
   $ mkdir d1
   $ cd d1
   $ echo c2 > f2
   $ hg add f2
   $ hg ci -m1
   $ cd ../..
 
   $ nlinksdir r1/.hg/store
   1 r1/.hg/store/00changelog.i
   1 r1/.hg/store/00manifest.i
   1 r1/.hg/store/data/d1/f2.i
   1 r1/.hg/store/data/f1.i
-  1 r1/.hg/store/fncache
+  1 r1/.hg/store/fncache (repofncache !)
   1 r1/.hg/store/phaseroots
   1 r1/.hg/store/undo
-  1 r1/.hg/store/undo.backup.fncache
+  1 r1/.hg/store/undo.backup.fncache (repofncache !)
   1 r1/.hg/store/undo.backupfiles
   1 r1/.hg/store/undo.phaseroots
 
 
 Create hardlinked clone r2:
 
   $ hg clone -U --debug r1 r2 --config progress.debug=true
   linking: 1
   linking: 2
   linking: 3
   linking: 4
   linking: 5
   linking: 6
   linking: 7
   linked 7 files
 
 Create non-hardlinked clone r3:
 
   $ hg clone --pull r1 r3
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 2 changes to 2 files
   new changesets 40d85e9847f2:7069c422939c
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 
 Repos r1 and r2 should now contain hardlinked files:
 
   $ nlinksdir r1/.hg/store
   2 r1/.hg/store/00changelog.i
   2 r1/.hg/store/00manifest.i
   2 r1/.hg/store/data/d1/f2.i
   2 r1/.hg/store/data/f1.i
-  2 r1/.hg/store/fncache
+  2 r1/.hg/store/fncache (repofncache !)
   1 r1/.hg/store/phaseroots
   1 r1/.hg/store/undo
-  1 r1/.hg/store/undo.backup.fncache
+  1 r1/.hg/store/undo.backup.fncache (repofncache !)
   1 r1/.hg/store/undo.backupfiles
   1 r1/.hg/store/undo.phaseroots
 
   $ nlinksdir r2/.hg/store
   2 r2/.hg/store/00changelog.i
   2 r2/.hg/store/00manifest.i
   2 r2/.hg/store/data/d1/f2.i
   2 r2/.hg/store/data/f1.i
-  2 r2/.hg/store/fncache
+  2 r2/.hg/store/fncache (repofncache !)
 
 Repo r3 should not be hardlinked:
 
   $ nlinksdir r3/.hg/store
   1 r3/.hg/store/00changelog.i
   1 r3/.hg/store/00manifest.i
   1 r3/.hg/store/data/d1/f2.i
   1 r3/.hg/store/data/f1.i
-  1 r3/.hg/store/fncache
+  1 r3/.hg/store/fncache (repofncache !)
   1 r3/.hg/store/phaseroots
   1 r3/.hg/store/undo
   1 r3/.hg/store/undo.backupfiles
   1 r3/.hg/store/undo.phaseroots
 
 
 Create a non-inlined filelog in r3:
 
   $ cd r3/d1
   >>> f = open('data1', 'wb')
   >>> for x in range(10000):
   ...     f.write("%s\n" % str(x))
   >>> f.close()
   $ for j in 0 1 2 3 4 5 6 7 8 9; do
   >   cat data1 >> f2
   >   hg commit -m$j
   > done
   $ cd ../..
 
   $ nlinksdir r3/.hg/store
   1 r3/.hg/store/00changelog.i
   1 r3/.hg/store/00manifest.i
   1 r3/.hg/store/data/d1/f2.d
   1 r3/.hg/store/data/d1/f2.i
   1 r3/.hg/store/data/f1.i
-  1 r3/.hg/store/fncache
+  1 r3/.hg/store/fncache (repofncache !)
   1 r3/.hg/store/phaseroots
   1 r3/.hg/store/undo
-  1 r3/.hg/store/undo.backup.fncache
+  1 r3/.hg/store/undo.backup.fncache (repofncache !)
   1 r3/.hg/store/undo.backup.phaseroots
   1 r3/.hg/store/undo.backupfiles
   1 r3/.hg/store/undo.phaseroots
 
 Push to repo r1 should break up most hardlinks in r2:
 
   $ hg -R r2 verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 2 changesets, 2 total revisions
 
   $ cd r3
   $ hg push
   pushing to $TESTTMP/r1
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 10 changesets with 10 changes to 1 files
 
   $ cd ..
 
   $ nlinksdir r2/.hg/store
   1 r2/.hg/store/00changelog.i
   1 r2/.hg/store/00manifest.i
   1 r2/.hg/store/data/d1/f2.i
   2 r2/.hg/store/data/f1.i
-  [12] r2/\.hg/store/fncache (re)
+  [12] r2/\.hg/store/fncache (re) (repofncache !)
 
-#if hardlink-whitelisted
+#if hardlink-whitelisted repofncache
   $ nlinksdir r2/.hg/store/fncache
   2 r2/.hg/store/fncache
 #endif
 
   $ hg -R r2 verify
   checking changesets
   checking manifests
   crosschecking files in changesets and manifests
   checking files
   2 files, 2 changesets, 2 total revisions
 
 
   $ cd r1
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Committing a change to f1 in r1 must break up hardlink f1.i in r2:
 
   $ echo c1c1 >> f1
   $ hg ci -m00
   $ cd ..
 
   $ nlinksdir r2/.hg/store
   1 r2/.hg/store/00changelog.i
   1 r2/.hg/store/00manifest.i
   1 r2/.hg/store/data/d1/f2.i
   1 r2/.hg/store/data/f1.i
-  [12] r2/\.hg/store/fncache (re)
+  [12] r2/\.hg/store/fncache (re) (repofncache !)
 
-#if hardlink-whitelisted
+#if hardlink-whitelisted repofncache
   $ nlinksdir r2/.hg/store/fncache
   2 r2/.hg/store/fncache
 #endif
 
 Create a file which exec permissions we will change
   $ cd r3
   $ echo "echo hello world" > f3
   $ hg add f3
   $ hg ci -mf3
   $ cd ..
 
   $ cd r3
   $ hg tip --template '{rev}:{node|short}\n'
   12:d3b77733a28a
   $ echo bla > f1
   $ chmod +x f3
   $ hg ci -m1
   $ cd ..
 
 Create hardlinked copy r4 of r3 (on Linux, we would call 'cp -al'):
 
   $ linkcp r3 r4
 
 'checklink' is produced by hardlinking a symlink, which is undefined whether
 the symlink should be followed or not. It does behave differently on Linux and
 BSD. Just remove it so the test pass on both platforms.
 
   $ rm -f r4/.hg/cache/checklink
 
 r4 has hardlinks in the working dir (not just inside .hg):
 
   $ nlinksdir r4
   2 r4/.hg/00changelog.i
   2 r4/.hg/branch
   2 r4/.hg/cache/branch2-base
   2 r4/.hg/cache/branch2-served
   2 r4/.hg/cache/checkisexec (execbit !)
   ? r4/.hg/cache/checklink-target (glob) (symlink !)
   2 r4/.hg/cache/checknoexec (execbit !)
   2 r4/.hg/cache/rbc-names-v1
   2 r4/.hg/cache/rbc-revs-v1
   2 r4/.hg/dirstate
   2 r4/.hg/fsmonitor.state (fsmonitor !)
   2 r4/.hg/hgrc
   2 r4/.hg/last-message.txt
   2 r4/.hg/requires
   2 r4/.hg/store/00changelog.i
   2 r4/.hg/store/00manifest.i
   2 r4/.hg/store/data/d1/f2.d
   2 r4/.hg/store/data/d1/f2.i
   2 r4/.hg/store/data/f1.i
   2 r4/.hg/store/data/f3.i
-  2 r4/.hg/store/fncache
+  2 r4/.hg/store/fncache (repofncache !)
   2 r4/.hg/store/phaseroots
   2 r4/.hg/store/undo
-  2 r4/.hg/store/undo.backup.fncache
+  2 r4/.hg/store/undo.backup.fncache (repofncache !)
   2 r4/.hg/store/undo.backup.phaseroots
   2 r4/.hg/store/undo.backupfiles
   2 r4/.hg/store/undo.phaseroots
   [24] r4/\.hg/undo\.backup\.dirstate (re)
   2 r4/.hg/undo.bookmarks
   2 r4/.hg/undo.branch
   2 r4/.hg/undo.desc
   [24] r4/\.hg/undo\.dirstate (re)
   2 r4/d1/data1
   2 r4/d1/f2
   2 r4/f1
   2 r4/f3
 
 Update back to revision 12 in r4 should break hardlink of file f1 and f3:
 #if hardlink-whitelisted
   $ nlinksdir r4/.hg/undo.backup.dirstate r4/.hg/undo.dirstate
   4 r4/.hg/undo.backup.dirstate
   4 r4/.hg/undo.dirstate
 #endif
 
 
   $ hg -R r4 up 12
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved (execbit !)
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved (no-execbit !)
 
   $ nlinksdir r4
   2 r4/.hg/00changelog.i
   1 r4/.hg/branch
   2 r4/.hg/cache/branch2-base
   2 r4/.hg/cache/branch2-served
   2 r4/.hg/cache/checkisexec (execbit !)
   2 r4/.hg/cache/checklink-target (symlink !)
   2 r4/.hg/cache/checknoexec (execbit !)
   2 r4/.hg/cache/rbc-names-v1
   2 r4/.hg/cache/rbc-revs-v1
   1 r4/.hg/dirstate
   1 r4/.hg/fsmonitor.state (fsmonitor !)
   2 r4/.hg/hgrc
   2 r4/.hg/last-message.txt
   2 r4/.hg/requires
   2 r4/.hg/store/00changelog.i
   2 r4/.hg/store/00manifest.i
   2 r4/.hg/store/data/d1/f2.d
   2 r4/.hg/store/data/d1/f2.i
   2 r4/.hg/store/data/f1.i
   2 r4/.hg/store/data/f3.i
   2 r4/.hg/store/fncache
   2 r4/.hg/store/phaseroots
   2 r4/.hg/store/undo
-  2 r4/.hg/store/undo.backup.fncache
+  2 r4/.hg/store/undo.backup.fncache (repofncache !)
   2 r4/.hg/store/undo.backup.phaseroots
   2 r4/.hg/store/undo.backupfiles
   2 r4/.hg/store/undo.phaseroots
   [24] r4/\.hg/undo\.backup\.dirstate (re)
   2 r4/.hg/undo.bookmarks
   2 r4/.hg/undo.branch
   2 r4/.hg/undo.desc
   [24] r4/\.hg/undo\.dirstate (re)
   2 r4/d1/data1
   2 r4/d1/f2
   1 r4/f1
   1 r4/f3 (execbit !)
   2 r4/f3 (no-execbit !)
 
 #if hardlink-whitelisted
   $ nlinksdir r4/.hg/undo.backup.dirstate r4/.hg/undo.dirstate
   4 r4/.hg/undo.backup.dirstate
   4 r4/.hg/undo.dirstate
 #endif
 
 Test hardlinking outside hg:
 
   $ mkdir x
   $ echo foo > x/a
 
   $ linkcp x y
   $ echo bar >> y/a
 
 No diff if hardlink:
 
   $ diff x/a y/a
 
 Test mq hardlinking:
 
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "mq=" >> $HGRCPATH
 
   $ hg init a
   $ cd a
 
   $ hg qimport -n foo - << EOF
   > # HG changeset patch
   > # Date 1 0
   > diff -r 2588a8b53d66 a
   > --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   > +++ b/a	Wed Jul 23 15:54:29 2008 +0200
   > @@ -0,0 +1,1 @@
   > +a
   > EOF
   adding foo to series file
 
   $ hg qpush
   applying foo
   now at: foo
 
   $ cd ..
   $ linkcp a b
   $ cd b
 
   $ hg qimport -n bar - << EOF
   > # HG changeset patch
   > # Date 2 0
   > diff -r 2588a8b53d66 a
   > --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   > +++ b/b	Wed Jul 23 15:54:29 2008 +0200
   > @@ -0,0 +1,1 @@
   > +b
   > EOF
   adding bar to series file
 
   $ hg qpush
   applying bar
   now at: bar
 
   $ cat .hg/patches/status
   430ed4828a74fa4047bc816a25500f7472ab4bfe:foo
   4e7abb4840c46a910f6d7b4d3c3fc7e5209e684c:bar
 
   $ cat .hg/patches/series
   foo
   bar
 
   $ cat ../a/.hg/patches/status
   430ed4828a74fa4047bc816a25500f7472ab4bfe:foo
 
   $ cat ../a/.hg/patches/series
   foo
 
 Test tags hardlinking:
 
   $ hg qdel -r qbase:qtip
   patch foo finalized without changeset message
   patch bar finalized without changeset message
 
   $ hg tag -l lfoo
   $ hg tag foo
 
   $ cd ..
   $ linkcp b c
   $ cd c
 
   $ hg tag -l -r 0 lbar
   $ hg tag -r 0 bar
 
   $ cat .hgtags
   4e7abb4840c46a910f6d7b4d3c3fc7e5209e684c foo
   430ed4828a74fa4047bc816a25500f7472ab4bfe bar
 
   $ cat .hg/localtags
   4e7abb4840c46a910f6d7b4d3c3fc7e5209e684c lfoo
   430ed4828a74fa4047bc816a25500f7472ab4bfe lbar
 
   $ cat ../b/.hgtags
   4e7abb4840c46a910f6d7b4d3c3fc7e5209e684c foo
 
   $ cat ../b/.hg/localtags
   4e7abb4840c46a910f6d7b4d3c3fc7e5209e684c lfoo
 
   $ cd ..

tests/test-hook.t

@@ -1,937 +1,937 b''
 commit hooks can see env vars
 (and post-transaction one are run unlocked)
 
 
   $ cat > $TESTTMP/txnabort.checkargs.py <<EOF
   > def showargs(ui, repo, hooktype, **kwargs):
   >     ui.write('%s Python hook: %s\n' % (hooktype, ','.join(sorted(kwargs))))
   > EOF
 
   $ hg init a
   $ cd a
   $ cat > .hg/hgrc <<EOF
   > [hooks]
   > commit = sh -c "HG_LOCAL= HG_TAG= printenv.py commit"
   > commit.b = sh -c "HG_LOCAL= HG_TAG= printenv.py commit.b"
   > precommit = sh -c  "HG_LOCAL= HG_NODE= HG_TAG= printenv.py precommit"
   > pretxncommit = sh -c "HG_LOCAL= HG_TAG= printenv.py pretxncommit"
   > pretxncommit.tip = hg -q tip
   > pre-identify = sh -c "printenv.py pre-identify 1"
   > pre-cat = sh -c "printenv.py pre-cat"
   > post-cat = sh -c "printenv.py post-cat"
   > pretxnopen = sh -c "HG_LOCAL= HG_TAG= printenv.py pretxnopen"
   > pretxnclose = sh -c "HG_LOCAL= HG_TAG= printenv.py pretxnclose"
   > txnclose = sh -c "HG_LOCAL= HG_TAG= printenv.py txnclose"
   > txnabort.0 = python:$TESTTMP/txnabort.checkargs.py:showargs
   > txnabort.1 = sh -c "HG_LOCAL= HG_TAG= printenv.py txnabort"
   > txnclose.checklock = sh -c "hg debuglock > /dev/null"
   > EOF
   $ echo a > a
   $ hg add a
   $ hg commit -m a
   precommit hook: HG_HOOKNAME=precommit HG_HOOKTYPE=precommit HG_PARENT1=0000000000000000000000000000000000000000
   pretxnopen hook: HG_HOOKNAME=pretxnopen HG_HOOKTYPE=pretxnopen HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   pretxncommit hook: HG_HOOKNAME=pretxncommit HG_HOOKTYPE=pretxncommit HG_NODE=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b HG_PARENT1=0000000000000000000000000000000000000000 HG_PENDING=$TESTTMP/a
   0:cb9a9f314b8b
   pretxnclose hook: HG_HOOKNAME=pretxnclose HG_HOOKTYPE=pretxnclose HG_PENDING=$TESTTMP/a HG_PHASES_MOVED=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   txnclose hook: HG_HOOKNAME=txnclose HG_HOOKTYPE=txnclose HG_PHASES_MOVED=1 HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   commit hook: HG_HOOKNAME=commit HG_HOOKTYPE=commit HG_NODE=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b HG_PARENT1=0000000000000000000000000000000000000000
   commit.b hook: HG_HOOKNAME=commit.b HG_HOOKTYPE=commit HG_NODE=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b HG_PARENT1=0000000000000000000000000000000000000000
 
   $ hg clone . ../b
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../b
 
 changegroup hooks can see env vars
 
   $ cat > .hg/hgrc <<EOF
   > [hooks]
   > prechangegroup = sh -c "printenv.py prechangegroup"
   > changegroup = sh -c "printenv.py changegroup"
   > incoming = sh -c "printenv.py incoming"
   > EOF
 
 pretxncommit and commit hooks can see both parents of merge
 
   $ cd ../a
   $ echo b >> a
   $ hg commit -m a1 -d "1 0"
   precommit hook: HG_HOOKNAME=precommit HG_HOOKTYPE=precommit HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   pretxnopen hook: HG_HOOKNAME=pretxnopen HG_HOOKTYPE=pretxnopen HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   pretxncommit hook: HG_HOOKNAME=pretxncommit HG_HOOKTYPE=pretxncommit HG_NODE=ab228980c14deea8b9555d91c9581127383e40fd HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b HG_PENDING=$TESTTMP/a
   1:ab228980c14d
   pretxnclose hook: HG_HOOKNAME=pretxnclose HG_HOOKTYPE=pretxnclose HG_PENDING=$TESTTMP/a HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   txnclose hook: HG_HOOKNAME=txnclose HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   commit hook: HG_HOOKNAME=commit HG_HOOKTYPE=commit HG_NODE=ab228980c14deea8b9555d91c9581127383e40fd HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   commit.b hook: HG_HOOKNAME=commit.b HG_HOOKTYPE=commit HG_NODE=ab228980c14deea8b9555d91c9581127383e40fd HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   $ hg update -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo b > b
   $ hg add b
   $ hg commit -m b -d '1 0'
   precommit hook: HG_HOOKNAME=precommit HG_HOOKTYPE=precommit HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   pretxnopen hook: HG_HOOKNAME=pretxnopen HG_HOOKTYPE=pretxnopen HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   pretxncommit hook: HG_HOOKNAME=pretxncommit HG_HOOKTYPE=pretxncommit HG_NODE=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b HG_PENDING=$TESTTMP/a
   2:ee9deb46ab31
   pretxnclose hook: HG_HOOKNAME=pretxnclose HG_HOOKTYPE=pretxnclose HG_PENDING=$TESTTMP/a HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   created new head
   txnclose hook: HG_HOOKNAME=txnclose HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   commit hook: HG_HOOKNAME=commit HG_HOOKTYPE=commit HG_NODE=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   commit.b hook: HG_HOOKNAME=commit.b HG_HOOKTYPE=commit HG_NODE=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT1=cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b
   $ hg merge 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -m merge -d '2 0'
   precommit hook: HG_HOOKNAME=precommit HG_HOOKTYPE=precommit HG_PARENT1=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT2=ab228980c14deea8b9555d91c9581127383e40fd
   pretxnopen hook: HG_HOOKNAME=pretxnopen HG_HOOKTYPE=pretxnopen HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   pretxncommit hook: HG_HOOKNAME=pretxncommit HG_HOOKTYPE=pretxncommit HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_PARENT1=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT2=ab228980c14deea8b9555d91c9581127383e40fd HG_PENDING=$TESTTMP/a
   3:07f3376c1e65
   pretxnclose hook: HG_HOOKNAME=pretxnclose HG_HOOKTYPE=pretxnclose HG_PENDING=$TESTTMP/a HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   txnclose hook: HG_HOOKNAME=txnclose HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   commit hook: HG_HOOKNAME=commit HG_HOOKTYPE=commit HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_PARENT1=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT2=ab228980c14deea8b9555d91c9581127383e40fd
   commit.b hook: HG_HOOKNAME=commit.b HG_HOOKTYPE=commit HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_PARENT1=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_PARENT2=ab228980c14deea8b9555d91c9581127383e40fd
 
 test generic hooks
 
   $ hg id
   pre-identify hook: HG_ARGS=id HG_HOOKNAME=pre-identify HG_HOOKTYPE=pre-identify HG_OPTS={'bookmarks': None, 'branch': None, 'id': None, 'insecure': None, 'num': None, 'remotecmd': '', 'rev': '', 'ssh': '', 'tags': None, 'template': ''} HG_PATS=[]
   abort: pre-identify hook exited with status 1
   [255]
   $ hg cat b
   pre-cat hook: HG_ARGS=cat b HG_HOOKNAME=pre-cat HG_HOOKTYPE=pre-cat HG_OPTS={'decode': None, 'exclude': [], 'include': [], 'output': '', 'rev': '', 'template': ''} HG_PATS=['b']
   b
   post-cat hook: HG_ARGS=cat b HG_HOOKNAME=post-cat HG_HOOKTYPE=post-cat HG_OPTS={'decode': None, 'exclude': [], 'include': [], 'output': '', 'rev': '', 'template': ''} HG_PATS=['b'] HG_RESULT=0
 
   $ cd ../b
   $ hg pull ../a
   pulling from ../a
   searching for changes
   prechangegroup hook: HG_HOOKNAME=prechangegroup HG_HOOKTYPE=prechangegroup HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_URL=file:$TESTTMP/a
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 2 changes to 2 files
   new changesets ab228980c14d:07f3376c1e65
   changegroup hook: HG_HOOKNAME=changegroup HG_HOOKTYPE=changegroup HG_NODE=ab228980c14deea8b9555d91c9581127383e40fd HG_NODE_LAST=07f3376c1e655977439df2a814e3cc14b27abac2 HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_URL=file:$TESTTMP/a
   incoming hook: HG_HOOKNAME=incoming HG_HOOKTYPE=incoming HG_NODE=ab228980c14deea8b9555d91c9581127383e40fd HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_URL=file:$TESTTMP/a
   incoming hook: HG_HOOKNAME=incoming HG_HOOKTYPE=incoming HG_NODE=ee9deb46ab31e4cc3310f3cf0c3d668e4d8fffc2 HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_URL=file:$TESTTMP/a
   incoming hook: HG_HOOKNAME=incoming HG_HOOKTYPE=incoming HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_URL=file:$TESTTMP/a
   (run 'hg update' to get a working copy)
 
 tag hooks can see env vars
 
   $ cd ../a
   $ cat >> .hg/hgrc <<EOF
   > pretag = sh -c "printenv.py pretag"
   > tag = sh -c "HG_PARENT1= HG_PARENT2= printenv.py tag"
   > EOF
   $ hg tag -d '3 0' a
   pretag hook: HG_HOOKNAME=pretag HG_HOOKTYPE=pretag HG_LOCAL=0 HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_TAG=a
   precommit hook: HG_HOOKNAME=precommit HG_HOOKTYPE=precommit HG_PARENT1=07f3376c1e655977439df2a814e3cc14b27abac2
   pretxnopen hook: HG_HOOKNAME=pretxnopen HG_HOOKTYPE=pretxnopen HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   pretxncommit hook: HG_HOOKNAME=pretxncommit HG_HOOKTYPE=pretxncommit HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PARENT1=07f3376c1e655977439df2a814e3cc14b27abac2 HG_PENDING=$TESTTMP/a
   4:539e4b31b6dc
   pretxnclose hook: HG_HOOKNAME=pretxnclose HG_HOOKTYPE=pretxnclose HG_PENDING=$TESTTMP/a HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   tag hook: HG_HOOKNAME=tag HG_HOOKTYPE=tag HG_LOCAL=0 HG_NODE=07f3376c1e655977439df2a814e3cc14b27abac2 HG_TAG=a
   txnclose hook: HG_HOOKNAME=txnclose HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   commit hook: HG_HOOKNAME=commit HG_HOOKTYPE=commit HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PARENT1=07f3376c1e655977439df2a814e3cc14b27abac2
   commit.b hook: HG_HOOKNAME=commit.b HG_HOOKTYPE=commit HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PARENT1=07f3376c1e655977439df2a814e3cc14b27abac2
   $ hg tag -l la
   pretag hook: HG_HOOKNAME=pretag HG_HOOKTYPE=pretag HG_LOCAL=1 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=la
   tag hook: HG_HOOKNAME=tag HG_HOOKTYPE=tag HG_LOCAL=1 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=la
 
 pretag hook can forbid tagging
 
   $ cat >> .hg/hgrc <<EOF
   > pretag.forbid = sh -c "printenv.py pretag.forbid 1"
   > EOF
   $ hg tag -d '4 0' fa
   pretag hook: HG_HOOKNAME=pretag HG_HOOKTYPE=pretag HG_LOCAL=0 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=fa
   pretag.forbid hook: HG_HOOKNAME=pretag.forbid HG_HOOKTYPE=pretag HG_LOCAL=0 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=fa
   abort: pretag.forbid hook exited with status 1
   [255]
   $ hg tag -l fla
   pretag hook: HG_HOOKNAME=pretag HG_HOOKTYPE=pretag HG_LOCAL=1 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=fla
   pretag.forbid hook: HG_HOOKNAME=pretag.forbid HG_HOOKTYPE=pretag HG_LOCAL=1 HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_TAG=fla
   abort: pretag.forbid hook exited with status 1
   [255]
 
 pretxncommit hook can see changeset, can roll back txn, changeset no
 more there after
 
   $ cat >> .hg/hgrc <<EOF
   > pretxncommit.forbid0 = sh -c "hg tip -q"
   > pretxncommit.forbid1 = sh -c "printenv.py pretxncommit.forbid 1"
   > EOF
   $ echo z > z
   $ hg add z
   $ hg -q tip
   4:539e4b31b6dc
   $ hg commit -m 'fail' -d '4 0'
   precommit hook: HG_HOOKNAME=precommit HG_HOOKTYPE=precommit HG_PARENT1=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10
   pretxnopen hook: HG_HOOKNAME=pretxnopen HG_HOOKTYPE=pretxnopen HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   pretxncommit hook: HG_HOOKNAME=pretxncommit HG_HOOKTYPE=pretxncommit HG_NODE=6f611f8018c10e827fee6bd2bc807f937e761567 HG_PARENT1=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PENDING=$TESTTMP/a
   5:6f611f8018c1
   5:6f611f8018c1
   pretxncommit.forbid hook: HG_HOOKNAME=pretxncommit.forbid1 HG_HOOKTYPE=pretxncommit HG_NODE=6f611f8018c10e827fee6bd2bc807f937e761567 HG_PARENT1=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PENDING=$TESTTMP/a
   transaction abort!
   txnabort Python hook: txnid,txnname
   txnabort hook: HG_HOOKNAME=txnabort.1 HG_HOOKTYPE=txnabort HG_TXNID=TXN:$ID$ HG_TXNNAME=commit
   rollback completed
   abort: pretxncommit.forbid1 hook exited with status 1
   [255]
   $ hg -q tip
   4:539e4b31b6dc
 
 (Check that no 'changelog.i.a' file were left behind)
 
   $ ls -1 .hg/store/
   00changelog.i
   00manifest.i
   data
-  fncache
+  fncache (repofncache !)
   journal.phaseroots
   phaseroots
   undo
-  undo.backup.fncache
+  undo.backup.fncache (repofncache !)
   undo.backupfiles
   undo.phaseroots
 
 
 precommit hook can prevent commit
 
   $ cat >> .hg/hgrc <<EOF
   > precommit.forbid = sh -c "printenv.py precommit.forbid 1"
   > EOF
   $ hg commit -m 'fail' -d '4 0'
   precommit hook: HG_HOOKNAME=precommit HG_HOOKTYPE=precommit HG_PARENT1=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10
   precommit.forbid hook: HG_HOOKNAME=precommit.forbid HG_HOOKTYPE=precommit HG_PARENT1=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10
   abort: precommit.forbid hook exited with status 1
   [255]
   $ hg -q tip
   4:539e4b31b6dc
 
 preupdate hook can prevent update
 
   $ cat >> .hg/hgrc <<EOF
   > preupdate = sh -c "printenv.py preupdate"
   > EOF
   $ hg update 1
   preupdate hook: HG_HOOKNAME=preupdate HG_HOOKTYPE=preupdate HG_PARENT1=ab228980c14d
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
 
 update hook
 
   $ cat >> .hg/hgrc <<EOF
   > update = sh -c "printenv.py update"
   > EOF
   $ hg update
   preupdate hook: HG_HOOKNAME=preupdate HG_HOOKTYPE=preupdate HG_PARENT1=539e4b31b6dc
   update hook: HG_ERROR=0 HG_HOOKNAME=update HG_HOOKTYPE=update HG_PARENT1=539e4b31b6dc
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 pushkey hook
 
   $ cat >> .hg/hgrc <<EOF
   > pushkey = sh -c "printenv.py pushkey"
   > EOF
   $ cd ../b
   $ hg bookmark -r null foo
   $ hg push -B foo ../a
   pushing to ../a
   searching for changes
   no changes found
   pretxnopen hook: HG_HOOKNAME=pretxnopen HG_HOOKTYPE=pretxnopen HG_TXNID=TXN:$ID$ HG_TXNNAME=push
   pretxnclose hook: HG_BOOKMARK_MOVED=1 HG_BUNDLE2=1 HG_HOOKNAME=pretxnclose HG_HOOKTYPE=pretxnclose HG_PENDING=$TESTTMP/a HG_SOURCE=push HG_TXNID=TXN:$ID$ HG_TXNNAME=push HG_URL=file:$TESTTMP/a
   pushkey hook: HG_BUNDLE2=1 HG_HOOKNAME=pushkey HG_HOOKTYPE=pushkey HG_KEY=foo HG_NAMESPACE=bookmarks HG_NEW=0000000000000000000000000000000000000000 HG_PUSHKEYCOMPAT=1 HG_SOURCE=push HG_TXNID=TXN:$ID$ HG_URL=file:$TESTTMP/a
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_BUNDLE2=1 HG_HOOKNAME=txnclose HG_HOOKTYPE=txnclose HG_SOURCE=push HG_TXNID=TXN:$ID$ HG_TXNNAME=push HG_URL=file:$TESTTMP/a
   exporting bookmark foo
   [1]
   $ cd ../a
 
 listkeys hook
 
   $ cat >> .hg/hgrc <<EOF
   > listkeys = sh -c "printenv.py listkeys"
   > EOF
   $ hg bookmark -r null bar
   pretxnopen hook: HG_HOOKNAME=pretxnopen HG_HOOKTYPE=pretxnopen HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   pretxnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=pretxnclose HG_HOOKTYPE=pretxnclose HG_PENDING=$TESTTMP/a HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ cd ../b
   $ hg pull -B bar ../a
   pulling from ../a
   listkeys hook: HG_HOOKNAME=listkeys HG_HOOKTYPE=listkeys HG_NAMESPACE=bookmarks HG_VALUES={'bar': '0000000000000000000000000000000000000000', 'foo': '0000000000000000000000000000000000000000'}
   no changes found
   adding remote bookmark bar
   $ cd ../a
 
 test that prepushkey can prevent incoming keys
 
   $ cat >> .hg/hgrc <<EOF
   > prepushkey = sh -c "printenv.py prepushkey.forbid 1"
   > EOF
   $ cd ../b
   $ hg bookmark -r null baz
   $ hg push -B baz ../a
   pushing to ../a
   searching for changes
   listkeys hook: HG_HOOKNAME=listkeys HG_HOOKTYPE=listkeys HG_NAMESPACE=phases HG_VALUES={'cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b': '1', 'publishing': 'True'}
   listkeys hook: HG_HOOKNAME=listkeys HG_HOOKTYPE=listkeys HG_NAMESPACE=bookmarks HG_VALUES={'bar': '0000000000000000000000000000000000000000', 'foo': '0000000000000000000000000000000000000000'}
   no changes found
   pretxnopen hook: HG_HOOKNAME=pretxnopen HG_HOOKTYPE=pretxnopen HG_TXNID=TXN:$ID$ HG_TXNNAME=push
   prepushkey.forbid hook: HG_BUNDLE2=1 HG_HOOKNAME=prepushkey HG_HOOKTYPE=prepushkey HG_KEY=baz HG_NAMESPACE=bookmarks HG_NEW=0000000000000000000000000000000000000000 HG_PUSHKEYCOMPAT=1 HG_SOURCE=push HG_TXNID=TXN:$ID$ HG_URL=file:$TESTTMP/a
   abort: prepushkey hook exited with status 1
   [255]
   $ cd ../a
 
 test that prelistkeys can prevent listing keys
 
   $ cat >> .hg/hgrc <<EOF
   > prelistkeys = sh -c "printenv.py prelistkeys.forbid 1"
   > EOF
   $ hg bookmark -r null quux
   pretxnopen hook: HG_HOOKNAME=pretxnopen HG_HOOKTYPE=pretxnopen HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   pretxnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=pretxnclose HG_HOOKTYPE=pretxnclose HG_PENDING=$TESTTMP/a HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   txnclose hook: HG_BOOKMARK_MOVED=1 HG_HOOKNAME=txnclose HG_HOOKTYPE=txnclose HG_TXNID=TXN:$ID$ HG_TXNNAME=bookmark
   $ cd ../b
   $ hg pull -B quux ../a
   pulling from ../a
   prelistkeys.forbid hook: HG_HOOKNAME=prelistkeys HG_HOOKTYPE=prelistkeys HG_NAMESPACE=bookmarks
   abort: prelistkeys hook exited with status 1
   [255]
   $ cd ../a
   $ rm .hg/hgrc
 
 prechangegroup hook can prevent incoming changes
 
   $ cd ../b
   $ hg -q tip
   3:07f3376c1e65
   $ cat > .hg/hgrc <<EOF
   > [hooks]
   > prechangegroup.forbid = sh -c "printenv.py prechangegroup.forbid 1"
   > EOF
   $ hg pull ../a
   pulling from ../a
   searching for changes
   prechangegroup.forbid hook: HG_HOOKNAME=prechangegroup.forbid HG_HOOKTYPE=prechangegroup HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_URL=file:$TESTTMP/a
   abort: prechangegroup.forbid hook exited with status 1
   [255]
 
 pretxnchangegroup hook can see incoming changes, can roll back txn,
 incoming changes no longer there after
 
   $ cat > .hg/hgrc <<EOF
   > [hooks]
   > pretxnchangegroup.forbid0 = hg tip -q
   > pretxnchangegroup.forbid1 = sh -c "printenv.py pretxnchangegroup.forbid 1"
   > EOF
   $ hg pull ../a
   pulling from ../a
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   4:539e4b31b6dc
   pretxnchangegroup.forbid hook: HG_HOOKNAME=pretxnchangegroup.forbid1 HG_HOOKTYPE=pretxnchangegroup HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_NODE_LAST=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_PENDING=$TESTTMP/b HG_SOURCE=pull HG_TXNID=TXN:$ID$ HG_URL=file:$TESTTMP/a
   transaction abort!
   rollback completed
   abort: pretxnchangegroup.forbid1 hook exited with status 1
   [255]
   $ hg -q tip
   3:07f3376c1e65
 
 outgoing hooks can see env vars
 
   $ rm .hg/hgrc
   $ cat > ../a/.hg/hgrc <<EOF
   > [hooks]
   > preoutgoing = sh -c "printenv.py preoutgoing"
   > outgoing = sh -c "printenv.py outgoing"
   > EOF
   $ hg pull ../a
   pulling from ../a
   searching for changes
   preoutgoing hook: HG_HOOKNAME=preoutgoing HG_HOOKTYPE=preoutgoing HG_SOURCE=pull
   outgoing hook: HG_HOOKNAME=outgoing HG_HOOKTYPE=outgoing HG_NODE=539e4b31b6dc99b3cfbaa6b53cbc1c1f9a1e3a10 HG_SOURCE=pull
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   adding remote bookmark quux
   new changesets 539e4b31b6dc
   (run 'hg update' to get a working copy)
   $ hg rollback
   repository tip rolled back to revision 3 (undo pull)
 
 preoutgoing hook can prevent outgoing changes
 
   $ cat >> ../a/.hg/hgrc <<EOF
   > preoutgoing.forbid = sh -c "printenv.py preoutgoing.forbid 1"
   > EOF
   $ hg pull ../a
   pulling from ../a
   searching for changes
   preoutgoing hook: HG_HOOKNAME=preoutgoing HG_HOOKTYPE=preoutgoing HG_SOURCE=pull
   preoutgoing.forbid hook: HG_HOOKNAME=preoutgoing.forbid HG_HOOKTYPE=preoutgoing HG_SOURCE=pull
   abort: preoutgoing.forbid hook exited with status 1
   [255]
 
 outgoing hooks work for local clones
 
   $ cd ..
   $ cat > a/.hg/hgrc <<EOF
   > [hooks]
   > preoutgoing = sh -c "printenv.py preoutgoing"
   > outgoing = sh -c "printenv.py outgoing"
   > EOF
   $ hg clone a c
   preoutgoing hook: HG_HOOKNAME=preoutgoing HG_HOOKTYPE=preoutgoing HG_SOURCE=clone
   outgoing hook: HG_HOOKNAME=outgoing HG_HOOKTYPE=outgoing HG_NODE=0000000000000000000000000000000000000000 HG_SOURCE=clone
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ rm -rf c
 
 preoutgoing hook can prevent outgoing changes for local clones
 
   $ cat >> a/.hg/hgrc <<EOF
   > preoutgoing.forbid = sh -c "printenv.py preoutgoing.forbid 1"
   > EOF
   $ hg clone a zzz
   preoutgoing hook: HG_HOOKNAME=preoutgoing HG_HOOKTYPE=preoutgoing HG_SOURCE=clone
   preoutgoing.forbid hook: HG_HOOKNAME=preoutgoing.forbid HG_HOOKTYPE=preoutgoing HG_SOURCE=clone
   abort: preoutgoing.forbid hook exited with status 1
   [255]
 
   $ cd "$TESTTMP/b"
 
   $ cat > hooktests.py <<EOF
   > from __future__ import print_function
   > from mercurial import error
   > 
   > uncallable = 0
   > 
   > def printargs(ui, args):
   >     a = list(args.items())
   >     a.sort()
   >     ui.write(b'hook args:\n')
   >     for k, v in a:
   >        ui.write(b'  %s %s\n' % (k, v))
   > 
   > def passhook(ui, repo, **args):
   >     printargs(ui, args)
   > 
   > def failhook(ui, repo, **args):
   >     printargs(ui, args)
   >     return True
   > 
   > class LocalException(Exception):
   >     pass
   > 
   > def raisehook(**args):
   >     raise LocalException(b'exception from hook')
   > 
   > def aborthook(**args):
   >     raise error.Abort(b'raise abort from hook')
   > 
   > def brokenhook(**args):
   >     return 1 + {}
   > 
   > def verbosehook(ui, **args):
   >     ui.note(b'verbose output from hook\n')
   > 
   > def printtags(ui, repo, **args):
   >     ui.write(b'%s\n' % sorted(repo.tags()))
   > 
   > class container:
   >     unreachable = 1
   > EOF
 
   $ cat > syntaxerror.py << EOF
   > (foo
   > EOF
 
 test python hooks
 
 #if windows
   $ PYTHONPATH="$TESTTMP/b;$PYTHONPATH"
 #else
   $ PYTHONPATH="$TESTTMP/b:$PYTHONPATH"
 #endif
   $ export PYTHONPATH
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.broken = python:hooktests.brokenhook' >> ../a/.hg/hgrc
   $ hg pull ../a 2>&1 | grep 'raised an exception'
   error: preoutgoing.broken hook raised an exception: unsupported operand type(s) for +: 'int' and 'dict'
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.raise = python:hooktests.raisehook' >> ../a/.hg/hgrc
   $ hg pull ../a 2>&1 | grep 'raised an exception'
   error: preoutgoing.raise hook raised an exception: exception from hook
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.abort = python:hooktests.aborthook' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   error: preoutgoing.abort hook failed: raise abort from hook
   abort: raise abort from hook
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.fail = python:hooktests.failhook' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   hook args:
     hooktype preoutgoing
     source pull
   abort: preoutgoing.fail hook failed
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.uncallable = python:hooktests.uncallable' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.uncallable hook is invalid: "hooktests.uncallable" is not callable
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.nohook = python:hooktests.nohook' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.nohook hook is invalid: "hooktests.nohook" is not defined
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.nomodule = python:nomodule' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.nomodule hook is invalid: "nomodule" not in a module
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.badmodule = python:nomodule.nowhere' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.badmodule hook is invalid: import of "nomodule" failed
   (run with --traceback for stack trace)
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.unreachable = python:hooktests.container.unreachable' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.unreachable hook is invalid: import of "hooktests.container" failed
   (run with --traceback for stack trace)
   [255]
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.syntaxerror = python:syntaxerror.syntaxerror' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   abort: preoutgoing.syntaxerror hook is invalid: import of "syntaxerror" failed
   (run with --traceback for stack trace)
   [255]
 
 The second egrep is to filter out lines like '    ^', which are slightly
 different between Python 2.6 and Python 2.7.
   $ hg pull ../a --traceback 2>&1 | egrep -v '^( +File|    [_a-zA-Z*(])' | egrep -v '^( )+(\^)?$'
   pulling from ../a
   searching for changes
   exception from first failed import attempt:
   Traceback (most recent call last):
   SyntaxError: * (glob)
   exception from second failed import attempt:
   Traceback (most recent call last):
   ImportError: No module named hgext_syntaxerror
   Traceback (most recent call last):
   HookLoadError: preoutgoing.syntaxerror hook is invalid: import of "syntaxerror" failed
   abort: preoutgoing.syntaxerror hook is invalid: import of "syntaxerror" failed
 
   $ echo '[hooks]' > ../a/.hg/hgrc
   $ echo 'preoutgoing.pass = python:hooktests.passhook' >> ../a/.hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   hook args:
     hooktype preoutgoing
     source pull
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   adding remote bookmark quux
   new changesets 539e4b31b6dc
   (run 'hg update' to get a working copy)
 
 post- python hooks that fail to *run* don't cause an abort
   $ rm ../a/.hg/hgrc
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'post-pull.broken = python:hooktests.brokenhook' >> .hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   no changes found
   error: post-pull.broken hook raised an exception: unsupported operand type(s) for +: 'int' and 'dict'
   (run with --traceback for stack trace)
 
 but post- python hooks that fail to *load* do
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'post-pull.nomodule = python:nomodule' >> .hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   no changes found
   abort: post-pull.nomodule hook is invalid: "nomodule" not in a module
   [255]
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'post-pull.badmodule = python:nomodule.nowhere' >> .hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   no changes found
   abort: post-pull.badmodule hook is invalid: import of "nomodule" failed
   (run with --traceback for stack trace)
   [255]
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'post-pull.nohook = python:hooktests.nohook' >> .hg/hgrc
   $ hg pull ../a
   pulling from ../a
   searching for changes
   no changes found
   abort: post-pull.nohook hook is invalid: "hooktests.nohook" is not defined
   [255]
 
 make sure --traceback works
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'commit.abort = python:hooktests.aborthook' >> .hg/hgrc
 
   $ echo aa > a
   $ hg --traceback commit -d '0 0' -ma 2>&1 | grep '^Traceback'
   Traceback (most recent call last):
 
   $ cd ..
   $ hg init c
   $ cd c
 
   $ cat > hookext.py <<EOF
   > def autohook(ui, **args):
   >     ui.write('Automatically installed hook\n')
   > 
   > def reposetup(ui, repo):
   >     repo.ui.setconfig("hooks", "commit.auto", autohook)
   > EOF
   $ echo '[extensions]' >> .hg/hgrc
   $ echo 'hookext = hookext.py' >> .hg/hgrc
 
   $ touch foo
   $ hg add foo
   $ hg ci -d '0 0' -m 'add foo'
   Automatically installed hook
   $ echo >> foo
   $ hg ci --debug -d '0 0' -m 'change foo'
   committing files:
   foo
   committing manifest
   committing changelog
   updating the branch cache
   committed changeset 1:52998019f6252a2b893452765fcb0a47351a5708
   calling hook commit.auto: hgext_hookext.autohook
   Automatically installed hook
 
   $ hg showconfig hooks
   hooks.commit.auto=<function autohook at *> (glob)
 
 test python hook configured with python:[file]:[hook] syntax
 
   $ cd ..
   $ mkdir d
   $ cd d
   $ hg init repo
   $ mkdir hooks
 
   $ cd hooks
   $ cat > testhooks.py <<EOF
   > def testhook(ui, **args):
   >     ui.write(b'hook works\n')
   > EOF
   $ echo '[hooks]' > ../repo/.hg/hgrc
   $ echo "pre-commit.test = python:`pwd`/testhooks.py:testhook" >> ../repo/.hg/hgrc
 
   $ cd ../repo
   $ hg commit -d '0 0'
   hook works
   nothing changed
   [1]
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo "update.ne = python:`pwd`/nonexistent.py:testhook" >> .hg/hgrc
   $ echo "pre-identify.npmd = python:`pwd`/:no_python_module_dir" >> .hg/hgrc
 
   $ hg up null
   loading update.ne hook failed:
   abort: $ENOENT$: $TESTTMP/d/repo/nonexistent.py
   [255]
 
   $ hg id
   loading pre-identify.npmd hook failed:
   abort: No module named repo!
   [255]
 
   $ cd ../../b
 
 make sure --traceback works on hook import failure
 
   $ cat > importfail.py <<EOF
   > import somebogusmodule
   > # dereference something in the module to force demandimport to load it
   > somebogusmodule.whatever
   > EOF
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'precommit.importfail = python:importfail.whatever' >> .hg/hgrc
 
   $ echo a >> a
   $ hg --traceback commit -ma 2>&1 | egrep -v '^( +File|    [a-zA-Z(])'
   exception from first failed import attempt:
   Traceback (most recent call last):
   ImportError: No module named somebogusmodule
   exception from second failed import attempt:
   Traceback (most recent call last):
   ImportError: No module named hgext_importfail
   Traceback (most recent call last):
   HookLoadError: precommit.importfail hook is invalid: import of "importfail" failed
   abort: precommit.importfail hook is invalid: import of "importfail" failed
 
 Issue1827: Hooks Update & Commit not completely post operation
 
 commit and update hooks should run after command completion.  The largefiles
 use demonstrates a recursive wlock, showing the hook doesn't run until the
 final release (and dirstate flush).
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'commit = hg id' >> .hg/hgrc
   $ echo 'update = hg id' >> .hg/hgrc
   $ echo bb > a
   $ hg ci -ma
   223eafe2750c tip
   $ hg up 0 --config extensions.largefiles=
   The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
   cb9a9f314b8b
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 make sure --verbose (and --quiet/--debug etc.) are propagated to the local ui
 that is passed to pre/post hooks
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'pre-identify = python:hooktests.verbosehook' >> .hg/hgrc
   $ hg id
   cb9a9f314b8b
   $ hg id --verbose
   calling hook pre-identify: hooktests.verbosehook
   verbose output from hook
   cb9a9f314b8b
 
 Ensure hooks can be prioritized
 
   $ echo '[hooks]' > .hg/hgrc
   $ echo 'pre-identify.a = python:hooktests.verbosehook' >> .hg/hgrc
   $ echo 'pre-identify.b = python:hooktests.verbosehook' >> .hg/hgrc
   $ echo 'priority.pre-identify.b = 1' >> .hg/hgrc
   $ echo 'pre-identify.c = python:hooktests.verbosehook' >> .hg/hgrc
   $ hg id --verbose
   calling hook pre-identify.b: hooktests.verbosehook
   verbose output from hook
   calling hook pre-identify.a: hooktests.verbosehook
   verbose output from hook
   calling hook pre-identify.c: hooktests.verbosehook
   verbose output from hook
   cb9a9f314b8b
 
 new tags must be visible in pretxncommit (issue3210)
 
   $ echo 'pretxncommit.printtags = python:hooktests.printtags' >> .hg/hgrc
   $ hg tag -f foo
   ['a', 'foo', 'tip']
 
 post-init hooks must not crash (issue4983)
 This also creates the `to` repo for the next test block.
 
   $ cd ..
   $ cat << EOF >> hgrc-with-post-init-hook
   > [hooks]
   > post-init = sh -c "printenv.py post-init"
   > EOF
   $ HGRCPATH=hgrc-with-post-init-hook hg init to
   post-init hook: HG_ARGS=init to HG_HOOKNAME=post-init HG_HOOKTYPE=post-init HG_OPTS={'insecure': None, 'remotecmd': '', 'ssh': ''} HG_PATS=['to'] HG_RESULT=0
 
 new commits must be visible in pretxnchangegroup (issue3428)
 
   $ echo '[hooks]' >> to/.hg/hgrc
   $ echo 'prechangegroup = hg --traceback tip' >> to/.hg/hgrc
   $ echo 'pretxnchangegroup = hg --traceback tip' >> to/.hg/hgrc
   $ echo a >> to/a
   $ hg --cwd to ci -Ama
   adding a
   $ hg clone to from
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo aa >> from/a
   $ hg --cwd from ci -mb
   $ hg --cwd from push
   pushing to $TESTTMP/to
   searching for changes
   changeset:   0:cb9a9f314b8b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   changeset:   1:9836a07b9b9d
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
 
 pretxnclose hook failure should abort the transaction
 
   $ hg init txnfailure
   $ cd txnfailure
   $ touch a && hg commit -Aqm a
   $ cat >> .hg/hgrc <<EOF
   > [hooks]
   > pretxnclose.error = exit 1
   > EOF
   $ hg strip -r 0 --config extensions.strip=
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to * (glob)
   transaction abort!
   rollback completed
   strip failed, backup bundle stored in * (glob)
   abort: pretxnclose.error hook exited with status 1
   [255]
   $ hg recover
   no interrupted transaction available
   [1]
   $ cd ..
 
 check whether HG_PENDING makes pending changes only in related
 repositories visible to an external hook.
 
 (emulate a transaction running concurrently by copied
 .hg/store/00changelog.i.a in subsequent test)
 
   $ cat > $TESTTMP/savepending.sh <<EOF
   > cp .hg/store/00changelog.i.a  .hg/store/00changelog.i.a.saved
   > exit 1 # to avoid adding new revision for subsequent tests
   > EOF
   $ cd a
   $ hg tip -q
   4:539e4b31b6dc
   $ hg --config hooks.pretxnclose="sh $TESTTMP/savepending.sh" commit -m "invisible"
   transaction abort!
   rollback completed
   abort: pretxnclose hook exited with status 1
   [255]
   $ cp .hg/store/00changelog.i.a.saved .hg/store/00changelog.i.a
 
 (check (in)visibility of new changeset while transaction running in
 repo)
 
   $ cat > $TESTTMP/checkpending.sh <<EOF
   > echo '@a'
   > hg -R "$TESTTMP/a" tip -q
   > echo '@a/nested'
   > hg -R "$TESTTMP/a/nested" tip -q
   > exit 1 # to avoid adding new revision for subsequent tests
   > EOF
   $ hg init nested
   $ cd nested
   $ echo a > a
   $ hg add a
   $ hg --config hooks.pretxnclose="sh $TESTTMP/checkpending.sh" commit -m '#0'
   @a
   4:539e4b31b6dc
   @a/nested
   0:bf5e395ced2c
   transaction abort!
   rollback completed
   abort: pretxnclose hook exited with status 1
   [255]
 
 Hook from untrusted hgrc are reported as failure
 ================================================
 
   $ cat << EOF > $TESTTMP/untrusted.py
   > from mercurial import scmutil, util
   > def uisetup(ui):
   >     class untrustedui(ui.__class__):
   >         def _trusted(self, fp, f):
   >             if util.normpath(fp.name).endswith(b'untrusted/.hg/hgrc'):
   >                 return False
   >             return super(untrustedui, self)._trusted(fp, f)
   >     ui.__class__ = untrustedui
   > EOF
   $ cat << EOF >> $HGRCPATH
   > [extensions]
   > untrusted=$TESTTMP/untrusted.py
   > EOF
   $ hg init untrusted
   $ cd untrusted
 
 Non-blocking hook
 -----------------
 
   $ cat << EOF >> .hg/hgrc
   > [hooks]
   > txnclose.testing=echo txnclose hook called
   > EOF
   $ touch a && hg commit -Aqm a
   warning: untrusted hook txnclose.testing not executed
   $ hg log
   changeset:   0:3903775176ed
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
 
 Non-blocking hook
 -----------------
 
   $ cat << EOF >> .hg/hgrc
   > [hooks]
   > pretxnclose.testing=echo pre-txnclose hook called
   > EOF
   $ touch b && hg commit -Aqm a
   transaction abort!
   rollback completed
   abort: untrusted hook pretxnclose.testing not executed
   (see 'hg help config.trusted')
   [255]
   $ hg log
   changeset:   0:3903775176ed
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   

tests/test-inherit-mode.t

@@ -1,160 +1,160 b''
 #require unix-permissions
 
 test that new files created in .hg inherit the permissions from .hg/store
 
   $ mkdir dir
 
 just in case somebody has a strange $TMPDIR
 
   $ chmod g-s dir
   $ cd dir
 
   $ cat >printmodes.py <<EOF
   > from __future__ import absolute_import, print_function
   > import os
   > import sys
   > 
   > allnames = []
   > isdir = {}
   > for root, dirs, files in os.walk(sys.argv[1]):
   >     for d in dirs:
   >         name = os.path.join(root, d)
   >         isdir[name] = 1
   >         allnames.append(name)
   >     for f in files:
   >         name = os.path.join(root, f)
   >         allnames.append(name)
   > allnames.sort()
   > for name in allnames:
   >     suffix = name in isdir and '/' or ''
   >     print('%05o %s%s' % (os.lstat(name).st_mode & 0o7777, name, suffix))
   > EOF
 
   $ cat >mode.py <<EOF
   > from __future__ import absolute_import, print_function
   > import os
   > import sys
   > print('%05o' % os.lstat(sys.argv[1]).st_mode)
   > EOF
 
   $ umask 077
 
   $ hg init repo
   $ cd repo
 
   $ chmod 0770 .hg/store
 
 before commit
 store can be written by the group, other files cannot
 store is setgid
 
   $ $PYTHON ../printmodes.py .
   00700 ./.hg/
   00600 ./.hg/00changelog.i
   00600 ./.hg/requires
   00770 ./.hg/store/
 
   $ mkdir dir
   $ touch foo dir/bar
   $ hg ci -qAm 'add files'
 
 after commit
 working dir files can only be written by the owner
 files created in .hg can be written by the group
 (in particular, store/**, dirstate, branch cache file, undo files)
 new directories are setgid
 
   $ $PYTHON ../printmodes.py .
   00700 ./.hg/
   00600 ./.hg/00changelog.i
   00770 ./.hg/cache/
   00660 ./.hg/cache/branch2-served
   00660 ./.hg/cache/rbc-names-v1
   00660 ./.hg/cache/rbc-revs-v1
   00660 ./.hg/dirstate
   00660 ./.hg/fsmonitor.state (fsmonitor !)
   00660 ./.hg/last-message.txt
   00600 ./.hg/requires
   00770 ./.hg/store/
   00660 ./.hg/store/00changelog.i
   00660 ./.hg/store/00manifest.i
   00770 ./.hg/store/data/
   00770 ./.hg/store/data/dir/
   00660 ./.hg/store/data/dir/bar.i
   00660 ./.hg/store/data/foo.i
-  00660 ./.hg/store/fncache
+  00660 ./.hg/store/fncache (repofncache !)
   00660 ./.hg/store/phaseroots
   00660 ./.hg/store/undo
   00660 ./.hg/store/undo.backupfiles
   00660 ./.hg/store/undo.phaseroots
   00660 ./.hg/undo.backup.dirstate
   00660 ./.hg/undo.bookmarks
   00660 ./.hg/undo.branch
   00660 ./.hg/undo.desc
   00660 ./.hg/undo.dirstate
   00700 ./dir/
   00600 ./dir/bar
   00600 ./foo
 
   $ umask 007
   $ hg init ../push
 
 before push
 group can write everything
 
   $ $PYTHON ../printmodes.py ../push
   00770 ../push/.hg/
   00660 ../push/.hg/00changelog.i
   00660 ../push/.hg/requires
   00770 ../push/.hg/store/
 
   $ umask 077
   $ hg -q push ../push
 
 after push
 group can still write everything
 
   $ $PYTHON ../printmodes.py ../push
   00770 ../push/.hg/
   00660 ../push/.hg/00changelog.i
   00770 ../push/.hg/cache/
   00660 ../push/.hg/cache/branch2-base
   00660 ../push/.hg/dirstate
   00660 ../push/.hg/requires
   00770 ../push/.hg/store/
   00660 ../push/.hg/store/00changelog.i
   00660 ../push/.hg/store/00manifest.i
   00770 ../push/.hg/store/data/
   00770 ../push/.hg/store/data/dir/
   00660 ../push/.hg/store/data/dir/bar.i
   00660 ../push/.hg/store/data/foo.i
-  00660 ../push/.hg/store/fncache
+  00660 ../push/.hg/store/fncache (repofncache !)
   00660 ../push/.hg/store/undo
   00660 ../push/.hg/store/undo.backupfiles
   00660 ../push/.hg/store/undo.phaseroots
   00660 ../push/.hg/undo.bookmarks
   00660 ../push/.hg/undo.branch
   00660 ../push/.hg/undo.desc
   00660 ../push/.hg/undo.dirstate
 
 
 Test that we don't lose the setgid bit when we call chmod.
 Not all systems support setgid directories (e.g. HFS+), so
 just check that directories have the same mode.
 
   $ cd ..
   $ hg init setgid
   $ cd setgid
   $ chmod g+rwx .hg/store
   $ chmod g+s .hg/store 2> /dev/null || true
   $ mkdir dir
   $ touch dir/file
   $ hg ci -qAm 'add dir/file'
   $ storemode=`$PYTHON ../mode.py .hg/store`
   $ dirmode=`$PYTHON ../mode.py .hg/store/data/dir`
   $ if [ "$storemode" != "$dirmode" ]; then
   >  echo "$storemode != $dirmode"
   > fi
   $ cd ..
 
   $ cd .. # g-s dir

tests/test-init.t

@@ -1,255 +1,263 b''
 This test tries to exercise the ssh functionality with a dummy script
 
   $ checknewrepo()
   > {
   >    name=$1
   >    if [ -d "$name"/.hg/store ]; then
   >    echo store created
   >    fi
   >    if [ -f "$name"/.hg/00changelog.i ]; then
   >    echo 00changelog.i created
   >    fi
   >    cat "$name"/.hg/requires
   > }
 
 creating 'local'
 
   $ hg init local
   $ checknewrepo local
   store created
   00changelog.i created
   dotencode
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
   $ echo this > local/foo
   $ hg ci --cwd local -A -m "init"
   adding foo
 
 test custom revlog chunk cache sizes
 
   $ hg --config format.chunkcachesize=0 log -R local -pv
   abort: revlog chunk cache size 0 is not greater than 0!
   [255]
   $ hg --config format.chunkcachesize=1023 log -R local -pv
   abort: revlog chunk cache size 1023 is not a power of 2!
   [255]
   $ hg --config format.chunkcachesize=1024 log -R local -pv
   changeset:   0:08b9e9f63b32
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       foo
   description:
   init
   
   
   diff -r 000000000000 -r 08b9e9f63b32 foo
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/foo	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +this
   
 
 creating repo with format.usestore=false
 
   $ hg --config format.usestore=false init old
   $ checknewrepo old
   generaldelta
   revlogv1
+  testonly-simplestore (reposimplestore !)
 
 creating repo with format.usefncache=false
 
   $ hg --config format.usefncache=false init old2
   $ checknewrepo old2
   store created
   00changelog.i created
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
 creating repo with format.dotencode=false
 
   $ hg --config format.dotencode=false init old3
   $ checknewrepo old3
   store created
   00changelog.i created
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
 creating repo with format.dotencode=false
 
   $ hg --config format.generaldelta=false --config format.usegeneraldelta=false init old4
   $ checknewrepo old4
   store created
   00changelog.i created
   dotencode
   fncache
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
 test failure
 
   $ hg init local
   abort: repository local already exists!
   [255]
 
 init+push to remote2
 
   $ hg init -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/remote2
   $ hg incoming -R remote2 local
   comparing with local
   changeset:   0:08b9e9f63b32
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     init
   
 
   $ hg push -R local -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/remote2
   pushing to ssh://user@dummy/remote2
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
 
 clone to remote1
 
   $ hg clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" local ssh://user@dummy/remote1
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
 
 The largefiles extension doesn't crash
   $ hg clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" local ssh://user@dummy/remotelf --config extensions.largefiles=
   The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
   The fsmonitor extension is incompatible with the largefiles extension and has been disabled. (fsmonitor !)
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
 
 init to existing repo
 
   $ hg init -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" ssh://user@dummy/remote1
   abort: repository remote1 already exists!
   abort: could not create remote repo!
   [255]
 
 clone to existing repo
 
   $ hg clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" local ssh://user@dummy/remote1
   abort: repository remote1 already exists!
   abort: could not create remote repo!
   [255]
 
 output of dummyssh
 
   $ cat dummylog
   Got arguments 1:user@dummy 2:hg init remote2
   Got arguments 1:user@dummy 2:hg -R remote2 serve --stdio
   Got arguments 1:user@dummy 2:hg -R remote2 serve --stdio
   Got arguments 1:user@dummy 2:hg init remote1
   Got arguments 1:user@dummy 2:hg -R remote1 serve --stdio
   Got arguments 1:user@dummy 2:hg init remotelf
   Got arguments 1:user@dummy 2:hg -R remotelf serve --stdio
   Got arguments 1:user@dummy 2:hg init remote1
   Got arguments 1:user@dummy 2:hg init remote1
 
 comparing repositories
 
   $ hg tip -q -R local
   0:08b9e9f63b32
   $ hg tip -q -R remote1
   0:08b9e9f63b32
   $ hg tip -q -R remote2
   0:08b9e9f63b32
 
 check names for repositories (clashes with URL schemes, special chars)
 
   $ for i in bundle file hg http https old-http ssh static-http "with space"; do
   >   printf "hg init \"$i\"... "
   >   hg init "$i"
   >   test -d "$i" -a -d "$i/.hg" && echo "ok" || echo "failed"
   > done
   hg init "bundle"... ok
   hg init "file"... ok
   hg init "hg"... ok
   hg init "http"... ok
   hg init "https"... ok
   hg init "old-http"... ok
   hg init "ssh"... ok
   hg init "static-http"... ok
   hg init "with space"... ok
 #if eol-in-paths
 /* " " is not a valid name for a directory on Windows */
   $ hg init " "
   $ test -d " "
   $ test -d " /.hg"
 #endif
 
 creating 'local/sub/repo'
 
   $ hg init local/sub/repo
   $ checknewrepo local/sub/repo
   store created
   00changelog.i created
   dotencode
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
 prepare test of init of url configured from paths
 
   $ echo '[paths]' >> $HGRCPATH
   $ echo "somewhere = `pwd`/url from paths" >> $HGRCPATH
   $ echo "elsewhere = `pwd`/another paths url" >> $HGRCPATH
 
 init should (for consistency with clone) expand the url
 
   $ hg init somewhere
   $ checknewrepo "url from paths"
   store created
   00changelog.i created
   dotencode
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
 verify that clone also expand urls
 
   $ hg clone somewhere elsewhere
   updating to branch default
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ checknewrepo "another paths url"
   store created
   00changelog.i created
   dotencode
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
 clone bookmarks
 
   $ hg -R local bookmark test
   $ hg -R local bookmarks
    * test                      0:08b9e9f63b32
   $ hg clone -e "\"$PYTHON\" \"$TESTDIR/dummyssh\"" local ssh://user@dummy/remote-bookmarks
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 1 changesets with 1 changes to 1 files
   exporting bookmark test
   $ hg -R remote-bookmarks bookmarks
      test                      0:08b9e9f63b32

tests/test-narrow-clone-no-ellipsis.t

@@ -1,130 +1,131 b''
   $ . "$TESTDIR/narrow-library.sh"
 
   $ hg init master
   $ cd master
   $ mkdir dir
   $ mkdir dir/src
   $ cd dir/src
   $ for x in `$TESTDIR/seq.py 20`; do echo $x > "f$x"; hg add "f$x"; hg commit -m "Commit src $x"; done
   $ cd ..
   $ mkdir tests
   $ cd tests
   $ for x in `$TESTDIR/seq.py 20`; do echo $x > "t$x"; hg add "t$x"; hg commit -m "Commit test $x"; done
   $ cd ../../..
 
 narrow clone a file, f10
 
   $ hg clone --narrow ssh://user@dummy/master narrow --noupdate --include "dir/src/f10"
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 40 changesets with 1 changes to 1 files
   new changesets *:* (glob)
   $ cd narrow
   $ cat .hg/requires | grep -v generaldelta
   dotencode
   fncache
   narrowhg-experimental
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
   $ cat .hg/narrowspec
   [includes]
   path:dir/src/f10
   [excludes]
   $ hg update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ find * | sort
   dir
   dir/src
   dir/src/f10
   $ cat dir/src/f10
   10
 
   $ cd ..
 
 narrow clone a directory, tests/, except tests/t19
 
   $ hg clone --narrow ssh://user@dummy/master narrowdir --noupdate --include "dir/tests/" --exclude "dir/tests/t19"
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 40 changesets with 19 changes to 19 files
   new changesets *:* (glob)
   $ cd narrowdir
   $ cat .hg/narrowspec
   [includes]
   path:dir/tests
   [excludes]
   path:dir/tests/t19
   $ hg update
   19 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ find * | sort
   dir
   dir/tests
   dir/tests/t1
   dir/tests/t10
   dir/tests/t11
   dir/tests/t12
   dir/tests/t13
   dir/tests/t14
   dir/tests/t15
   dir/tests/t16
   dir/tests/t17
   dir/tests/t18
   dir/tests/t2
   dir/tests/t20
   dir/tests/t3
   dir/tests/t4
   dir/tests/t5
   dir/tests/t6
   dir/tests/t7
   dir/tests/t8
   dir/tests/t9
 
   $ cd ..
 
 narrow clone everything but a directory (tests/)
 
   $ hg clone --narrow ssh://user@dummy/master narrowroot --noupdate --exclude "dir/tests"
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 40 changesets with 20 changes to 20 files
   new changesets *:* (glob)
   $ cd narrowroot
   $ cat .hg/narrowspec
   [includes]
   path:.
   [excludes]
   path:dir/tests
   $ hg update
   20 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ find * | sort
   dir
   dir/src
   dir/src/f1
   dir/src/f10
   dir/src/f11
   dir/src/f12
   dir/src/f13
   dir/src/f14
   dir/src/f15
   dir/src/f16
   dir/src/f17
   dir/src/f18
   dir/src/f19
   dir/src/f2
   dir/src/f20
   dir/src/f3
   dir/src/f4
   dir/src/f5
   dir/src/f6
   dir/src/f7
   dir/src/f8
   dir/src/f9
 
   $ cd ..

tests/test-narrow-clone.t

@@ -1,225 +1,226 b''
   $ . "$TESTDIR/narrow-library.sh"
 
   $ hg init master
   $ cd master
   $ cat >> .hg/hgrc <<EOF
   > [narrow]
   > serveellipses=True
   > EOF
   $ mkdir dir
   $ mkdir dir/src
   $ cd dir/src
   $ for x in `$TESTDIR/seq.py 20`; do echo $x > "f$x"; hg add "f$x"; hg commit -m "Commit src $x"; done
   $ cd ..
   $ mkdir tests
   $ cd tests
   $ for x in `$TESTDIR/seq.py 20`; do echo $x > "t$x"; hg add "t$x"; hg commit -m "Commit test $x"; done
   $ cd ../../..
 
 narrow clone a file, f10
 
   $ hg clone --narrow ssh://user@dummy/master narrow --noupdate --include "dir/src/f10"
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 1 changes to 1 files
   new changesets *:* (glob)
   $ cd narrow
   $ cat .hg/requires | grep -v generaldelta
   dotencode
   fncache
   narrowhg-experimental
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
   $ cat .hg/narrowspec
   [includes]
   path:dir/src/f10
   [excludes]
   $ hg tracked
   I path:dir/src/f10
   $ hg update
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ find * | sort
   dir
   dir/src
   dir/src/f10
   $ cat dir/src/f10
   10
 
   $ cd ..
 
 narrow clone with a newline should fail
 
   $ hg clone --narrow ssh://user@dummy/master narrow_fail --noupdate --include 'dir/src/f10
   > '
   requesting all changes
   abort: newlines are not allowed in narrowspec paths
   [255]
 
 narrow clone a directory, tests/, except tests/t19
 
   $ hg clone --narrow ssh://user@dummy/master narrowdir --noupdate --include "dir/tests/" --exclude "dir/tests/t19"
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 21 changesets with 19 changes to 19 files
   new changesets *:* (glob)
   $ cd narrowdir
   $ cat .hg/narrowspec
   [includes]
   path:dir/tests
   [excludes]
   path:dir/tests/t19
   $ hg tracked
   I path:dir/tests
   X path:dir/tests/t19
   $ hg update
   19 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ find * | sort
   dir
   dir/tests
   dir/tests/t1
   dir/tests/t10
   dir/tests/t11
   dir/tests/t12
   dir/tests/t13
   dir/tests/t14
   dir/tests/t15
   dir/tests/t16
   dir/tests/t17
   dir/tests/t18
   dir/tests/t2
   dir/tests/t20
   dir/tests/t3
   dir/tests/t4
   dir/tests/t5
   dir/tests/t6
   dir/tests/t7
   dir/tests/t8
   dir/tests/t9
 
   $ cd ..
 
 narrow clone everything but a directory (tests/)
 
   $ hg clone --narrow ssh://user@dummy/master narrowroot --noupdate --exclude "dir/tests"
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 21 changesets with 20 changes to 20 files
   new changesets *:* (glob)
   $ cd narrowroot
   $ cat .hg/narrowspec
   [includes]
   path:.
   [excludes]
   path:dir/tests
   $ hg tracked
   I path:.
   X path:dir/tests
   $ hg update
   20 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ find * | sort
   dir
   dir/src
   dir/src/f1
   dir/src/f10
   dir/src/f11
   dir/src/f12
   dir/src/f13
   dir/src/f14
   dir/src/f15
   dir/src/f16
   dir/src/f17
   dir/src/f18
   dir/src/f19
   dir/src/f2
   dir/src/f20
   dir/src/f3
   dir/src/f4
   dir/src/f5
   dir/src/f6
   dir/src/f7
   dir/src/f8
   dir/src/f9
 
   $ cd ..
 
 narrow clone no paths at all
 
   $ hg clone --narrow ssh://user@dummy/master narrowempty --noupdate
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files
   new changesets * (glob)
   $ cd narrowempty
   $ hg tracked
   $ hg update
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ ls
 
   $ cd ..
 
 simple clone
   $ hg clone ssh://user@dummy/master simpleclone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 40 changesets with 40 changes to 40 files
   new changesets * (glob)
   updating to branch default
   40 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd simpleclone
   $ find * | sort
   dir
   dir/src
   dir/src/f1
   dir/src/f10
   dir/src/f11
   dir/src/f12
   dir/src/f13
   dir/src/f14
   dir/src/f15
   dir/src/f16
   dir/src/f17
   dir/src/f18
   dir/src/f19
   dir/src/f2
   dir/src/f20
   dir/src/f3
   dir/src/f4
   dir/src/f5
   dir/src/f6
   dir/src/f7
   dir/src/f8
   dir/src/f9
   dir/tests
   dir/tests/t1
   dir/tests/t10
   dir/tests/t11
   dir/tests/t12
   dir/tests/t13
   dir/tests/t14
   dir/tests/t15
   dir/tests/t16
   dir/tests/t17
   dir/tests/t18
   dir/tests/t19
   dir/tests/t2
   dir/tests/t20
   dir/tests/t3
   dir/tests/t4
   dir/tests/t5
   dir/tests/t6
   dir/tests/t7
   dir/tests/t8
   dir/tests/t9
 
   $ cd ..

tests/test-narrow.t

@@ -1,392 +1,402 b''
 #testcases flat tree
 
   $ . "$TESTDIR/narrow-library.sh"
 
 #if tree
   $ cat << EOF >> $HGRCPATH
   > [experimental]
   > treemanifest = 1
   > EOF
 #endif
 
   $ hg init master
   $ cd master
   $ cat >> .hg/hgrc <<EOF
   > [narrow]
   > serveellipses=True
   > EOF
   $ for x in `$TESTDIR/seq.py 0 10`
   > do
   >   mkdir d$x
   >   echo $x > d$x/f
   >   hg add d$x/f
   >   hg commit -m "add d$x/f"
   > done
   $ hg log -T "{node|short}: {desc}\n"
   *: add d10/f (glob)
   *: add d9/f (glob)
   *: add d8/f (glob)
   *: add d7/f (glob)
   *: add d6/f (glob)
   *: add d5/f (glob)
   *: add d4/f (glob)
   *: add d3/f (glob)
   *: add d2/f (glob)
   *: add d1/f (glob)
   *: add d0/f (glob)
   $ cd ..
 
 Error if '.' or '..' are in the directory to track.
   $ hg clone --narrow ssh://user@dummy/master foo --include ./asdf
   requesting all changes
   abort: "." and ".." are not allowed in narrowspec paths
   [255]
   $ hg clone --narrow ssh://user@dummy/master foo --include asdf/..
   requesting all changes
   abort: "." and ".." are not allowed in narrowspec paths
   [255]
   $ hg clone --narrow ssh://user@dummy/master foo --include a/./c
   requesting all changes
   abort: "." and ".." are not allowed in narrowspec paths
   [255]
 
 Names with '.' in them are OK.
   $ hg clone --narrow ssh://user@dummy/master should-work --include a/.b/c
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files
   new changesets * (glob)
   updating to branch default
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Test repo with local changes
   $ hg clone --narrow ssh://user@dummy/master narrow-local-changes --include d0 --include d3 --include d6
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 6 changesets with 3 changes to 3 files
   new changesets *:* (glob)
   updating to branch default
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd narrow-local-changes
   $ cat >> $HGRCPATH << EOF
   > [experimental]
   > evolution=createmarkers
   > EOF
   $ echo local change >> d0/f
   $ hg ci -m 'local change to d0'
   $ hg co '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo local change >> d3/f
   $ hg ci -m 'local hidden change to d3'
   created new head
   $ hg ci --amend -m 'local change to d3'
   $ hg tracked --removeinclude d0
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   The following changeset(s) or their ancestors have local changes not on the remote:
   * (glob)
   abort: local changes found
   (use --force-delete-local-changes to ignore)
   [255]
 Check that nothing was removed by the failed attempts
   $ hg tracked
   I path:d0
   I path:d3
   I path:d6
   $ hg files
   d0/f
   d3/f
   d6/f
   $ find *
   d0
   d0/f
   d3
   d3/f
   d6
   d6/f
   $ hg verify -q
 Force deletion of local changes
   $ hg log -T "{node|short}: {desc} {outsidenarrow}\n"
   *: local change to d3  (glob)
   *: local change to d0  (glob)
   *: add d10/f outsidenarrow (glob)
   *: add d6/f  (glob)
   *: add d5/f outsidenarrow (glob)
   *: add d3/f  (glob)
   *: add d2/f outsidenarrow (glob)
   *: add d0/f  (glob)
   $ hg tracked --removeinclude d0 --force-delete-local-changes
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   The following changeset(s) or their ancestors have local changes not on the remote:
   * (glob)
   saved backup bundle to $TESTTMP/narrow-local-changes/.hg/strip-backup/*-narrow.hg (glob)
   deleting data/d0/f.i (reporevlogstore !)
+  deleting meta/d0/00manifest.i (tree !)
   deleting data/d0/f/362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (reposimplestore !)
   deleting data/d0/f/4374b5650fc5ae54ac857c0f0381971fdde376f7 (reposimplestore !)
   deleting data/d0/f/index (reposimplestore !)
-  deleting meta/d0/00manifest.i (tree !)
 
   $ hg log -T "{node|short}: {desc} {outsidenarrow}\n"
   *: local change to d3  (glob)
   *: add d10/f outsidenarrow (glob)
   *: add d6/f  (glob)
   *: add d5/f outsidenarrow (glob)
   *: add d3/f  (glob)
   *: add d2/f outsidenarrow (glob)
   *: add d0/f outsidenarrow (glob)
 Can restore stripped local changes after widening
   $ hg tracked --addinclude d0 -q
   $ hg unbundle .hg/strip-backup/*-narrow.hg -q
   $ hg --hidden co -r 'desc("local change to d0")' -q
   $ cat d0/f
   0
   local change
 Pruned commits affecting removed paths should not prevent narrowing
   $ hg co '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugobsolete `hg log -T '{node}' -r 'desc("local change to d0")'`
   obsoleted 1 changesets
   $ hg tracked --removeinclude d0
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   saved backup bundle to $TESTTMP/narrow-local-changes/.hg/strip-backup/*-narrow.hg (glob)
   deleting data/d0/f.i (reporevlogstore !)
+  deleting meta/d0/00manifest.i (tree !)
   deleting data/d0/f/362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (reposimplestore !)
   deleting data/d0/f/4374b5650fc5ae54ac857c0f0381971fdde376f7 (reposimplestore !)
   deleting data/d0/f/index (reposimplestore !)
-  deleting meta/d0/00manifest.i (tree !)
 
 Updates off of stripped commit if necessary
   $ hg co -r 'desc("local change to d3")' -q
   $ echo local change >> d6/f
   $ hg ci -m 'local change to d6'
   $ hg tracked --removeinclude d3 --force-delete-local-changes
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   The following changeset(s) or their ancestors have local changes not on the remote:
   * (glob)
   * (glob)
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/narrow-local-changes/.hg/strip-backup/*-narrow.hg (glob)
   deleting data/d3/f.i (reporevlogstore !)
+  deleting meta/d3/00manifest.i (tree !)
   deleting data/d3/f/2661d26c649684b482d10f91960cc3db683c38b4 (reposimplestore !)
   deleting data/d3/f/99fa7136105a15e2045ce3d9152e4837c5349e4d (reposimplestore !)
   deleting data/d3/f/index (reposimplestore !)
-  deleting meta/d3/00manifest.i (tree !)
   $ hg log -T '{desc}\n' -r .
   add d10/f
 Updates to nullid if necessary
   $ hg tracked --addinclude d3 -q
   $ hg co null -q
   $ mkdir d3
   $ echo local change > d3/f
   $ hg add d3/f
   $ hg ci -m 'local change to d3'
   created new head
   $ hg tracked --removeinclude d3 --force-delete-local-changes
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   The following changeset(s) or their ancestors have local changes not on the remote:
   * (glob)
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/narrow-local-changes/.hg/strip-backup/*-narrow.hg (glob)
   deleting data/d3/f.i (reporevlogstore !)
+  deleting meta/d3/00manifest.i (tree !)
   deleting data/d3/f/2661d26c649684b482d10f91960cc3db683c38b4 (reposimplestore !)
   deleting data/d3/f/5ce0767945cbdbca3b924bb9fbf5143f72ab40ac (reposimplestore !)
   deleting data/d3/f/index (reposimplestore !)
-  deleting meta/d3/00manifest.i (tree !)
   $ hg id
   000000000000
   $ cd ..
 
 Can remove last include, making repo empty
   $ hg clone --narrow ssh://user@dummy/master narrow-empty --include d0 -r 5
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 1 changes to 1 files
   new changesets *:* (glob)
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd narrow-empty
   $ hg tracked --removeinclude d0
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   deleting data/d0/f.i (reporevlogstore !)
+  deleting meta/d0/00manifest.i (tree !)
   deleting data/d0/f/362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (reposimplestore !)
   deleting data/d0/f/index (reposimplestore !)
-  deleting meta/d0/00manifest.i (tree !)
   $ hg tracked
   $ hg files
   [1]
   $ test -d d0
   [1]
 Do some work in the empty clone
   $ hg diff --change .
   $ hg branch foo
   marked working directory as branch foo
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -m empty
   $ hg pull -q
 Can widen the empty clone
   $ hg tracked --addinclude d0
   comparing with ssh://user@dummy/master
   searching for changes
   no changes found
   saved backup bundle to $TESTTMP/narrow-empty/.hg/strip-backup/*-widen.hg (glob)
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 1 changes to 1 files
   new changesets *:* (glob)
   $ hg tracked
   I path:d0
   $ hg files
   d0/f
   $ find *
   d0
   d0/f
   $ cd ..
 
 TODO(martinvonz): test including e.g. d3/g and then removing it once
 https://bitbucket.org/Google/narrowhg/issues/6 is fixed
 
   $ hg clone --narrow ssh://user@dummy/master narrow --include d0 --include d3 --include d6 --include d9
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 8 changesets with 4 changes to 4 files
   new changesets *:* (glob)
   updating to branch default
   4 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd narrow
   $ hg tracked
   I path:d0
   I path:d3
   I path:d6
   I path:d9
   $ hg tracked --removeinclude d6
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   deleting data/d6/f.i (reporevlogstore !)
+  deleting meta/d6/00manifest.i (tree !)
   deleting data/d6/f/7339d30678f451ac8c3f38753beeb4cf2e1655c7 (reposimplestore !)
   deleting data/d6/f/index (reposimplestore !)
-  deleting meta/d6/00manifest.i (tree !)
   $ hg tracked
   I path:d0
   I path:d3
   I path:d9
+#if repofncache
   $ hg debugrebuildfncache
   fncache already up to date
+#endif
   $ find *
   d0
   d0/f
   d3
   d3/f
   d9
   d9/f
   $ hg verify -q
   $ hg tracked --addexclude d3/f
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   deleting data/d3/f.i (reporevlogstore !)
+  deleting data/d3/f/2661d26c649684b482d10f91960cc3db683c38b4 (reposimplestore !)
+  deleting data/d3/f/index (reposimplestore !)
   $ hg tracked
   I path:d0
   I path:d3
   I path:d9
   X path:d3/f
+#if repofncache
   $ hg debugrebuildfncache
   fncache already up to date
+#endif
   $ find *
   d0
   d0/f
   d9
   d9/f
   $ hg verify -q
   $ hg tracked --addexclude d0
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   deleting data/d0/f.i (reporevlogstore !)
   deleting meta/d0/00manifest.i (tree !)
+  deleting data/d0/f/362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (reposimplestore !)
+  deleting data/d0/f/index (reposimplestore !)
   $ hg tracked
   I path:d3
   I path:d9
   X path:d0
   X path:d3/f
+#if repofncache
   $ hg debugrebuildfncache
   fncache already up to date
+#endif
   $ find *
   d9
   d9/f
 
 Make a 15 of changes to d9 to test the path without --verbose
 (Note: using regexes instead of "* (glob)" because if the test fails, it
 produces more sensible diffs)
   $ hg tracked
   I path:d3
   I path:d9
   X path:d0
   X path:d3/f
   $ for x in `$TESTDIR/seq.py 1 15`
   > do
   >   echo local change >> d9/f
   >   hg commit -m "change $x to d9/f"
   > done
   $ hg tracked --removeinclude d9
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   The following changeset(s) or their ancestors have local changes not on the remote:
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ...and 5 more, use --verbose to list all
   abort: local changes found
   (use --force-delete-local-changes to ignore)
   [255]
 Now test it *with* verbose.
   $ hg tracked --removeinclude d9 --verbose
   comparing with ssh://user@dummy/master
   searching for changes
   looking for local changes to affected paths
   The following changeset(s) or their ancestors have local changes not on the remote:
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   ^[0-9a-f]{12}$ (re)
   abort: local changes found
   (use --force-delete-local-changes to ignore)
   [255]

tests/test-repo-compengines.t

@@ -1,78 +1,81 b''
 A new repository uses zlib storage, which doesn't need a requirement
 
   $ hg init default
   $ cd default
   $ cat .hg/requires
   dotencode
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
   $ touch foo
   $ hg -q commit -A -m 'initial commit with a lot of repeated repeated repeated text to trigger compression'
   $ hg debugrevlog -c | grep 0x78
       0x78 (x)  :   1 (100.00%)
       0x78 (x)  : 110 (100.00%)
 
   $ cd ..
 
 Unknown compression engine to format.compression aborts
 
   $ hg --config experimental.format.compression=unknown init unknown
   abort: compression engine unknown defined by experimental.format.compression not available
   (run "hg debuginstall" to list available compression engines)
   [255]
 
 A requirement specifying an unknown compression engine results in bail
 
   $ hg init unknownrequirement
   $ cd unknownrequirement
   $ echo exp-compression-unknown >> .hg/requires
   $ hg log
   abort: repository requires features unknown to this Mercurial: exp-compression-unknown!
   (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
   [255]
 
   $ cd ..
 
 #if zstd
 
   $ hg --config experimental.format.compression=zstd init zstd
   $ cd zstd
   $ cat .hg/requires
   dotencode
   exp-compression-zstd
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
   $ touch foo
   $ hg -q commit -A -m 'initial commit with a lot of repeated repeated repeated text'
 
   $ hg debugrevlog -c | grep 0x28
       0x28      :  1 (100.00%)
       0x28      : 98 (100.00%)
 
   $ cd ..
 
 Specifying a new format.compression on an existing repo won't introduce data
 with that engine or a requirement
 
   $ cd default
   $ touch bar
   $ hg --config experimental.format.compression=zstd -q commit -A -m 'add bar with a lot of repeated repeated repeated text'
 
   $ cat .hg/requires
   dotencode
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
   $ hg debugrevlog -c | grep 0x78
       0x78 (x)  :   2 (100.00%)
       0x78 (x)  : 199 (100.00%)
 
 #endif

tests/test-sparse-requirement.t

@@ -1,65 +1,68 b''
   $ hg init repo
   $ cd repo
 
   $ touch a.html b.html c.py d.py
 
   $ cat > frontend.sparse << EOF
   > [include]
   > *.html
   > EOF
 
   $ hg -q commit -A -m initial
 
   $ echo 1 > a.html
   $ echo 1 > c.py
   $ hg commit -m 'commit 1'
 
 Enable sparse profile
 
   $ cat .hg/requires
   dotencode
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
   $ hg debugsparse --config extensions.sparse= --enable-profile frontend.sparse
   $ ls
   a.html
   b.html
 
 Requirement for sparse added when sparse is enabled
 
   $ cat .hg/requires
   dotencode
   exp-sparse
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
 Client without sparse enabled reacts properly
 
   $ hg files
   abort: repository is using sparse feature but sparse is not enabled; enable the "sparse" extensions to access!
   [255]
 
 Requirement for sparse is removed when sparse is disabled
 
   $ hg debugsparse --reset --config extensions.sparse=
 
   $ cat .hg/requires
   dotencode
   fncache
   generaldelta
   revlogv1
   store
+  testonly-simplestore (reposimplestore !)
 
 And client without sparse can access
 
   $ hg files
   a.html
   b.html
   c.py
   d.py
   frontend.sparse

tests/test-strip.t

@@ -1,1336 +1,1340 b''
   $ echo "[extensions]" >> $HGRCPATH
   $ echo "strip=" >> $HGRCPATH
   $ echo "drawdag=$TESTDIR/drawdag.py" >> $HGRCPATH
 
   $ restore() {
   >     hg unbundle -q .hg/strip-backup/*
   >     rm .hg/strip-backup/*
   > }
   $ teststrip() {
   >     hg up -C $1
   >     echo % before update $1, strip $2
   >     hg parents
   >     hg --traceback strip $2
   >     echo % after update $1, strip $2
   >     hg parents
   >     restore
   > }
 
   $ hg init test
   $ cd test
 
   $ echo foo > bar
   $ hg ci -Ama
   adding bar
 
   $ echo more >> bar
   $ hg ci -Amb
 
   $ echo blah >> bar
   $ hg ci -Amc
 
   $ hg up 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo blah >> bar
   $ hg ci -Amd
   created new head
 
   $ echo final >> bar
   $ hg ci -Ame
 
   $ hg log
   changeset:   4:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   changeset:   3:65bd5f99a4a3
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   2:264128213d29
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:9ab35a2d17cb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
 
   $ teststrip 4 4
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 4
   changeset:   4:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 4
   changeset:   3:65bd5f99a4a3
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   $ teststrip 4 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 3
   changeset:   4:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 3
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   $ teststrip 1 4
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 1, strip 4
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 1, strip 4
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   $ teststrip 4 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 2
   changeset:   4:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 2
   changeset:   3:443431ffac4f
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   $ teststrip 4 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   % before update 4, strip 1
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update 4, strip 1
   changeset:   0:9ab35a2d17cb
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ teststrip null 4
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   % before update null, strip 4
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   % after update null, strip 4
 
   $ hg log
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   changeset:   3:443431ffac4f
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     e
   
   changeset:   2:65bd5f99a4a3
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   changeset:   0:9ab35a2d17cb
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     a
   
   $ hg up -C 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg parents
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
 
   $ hg --traceback strip 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/264128213d29-0b39d6bf-backup.hg
   $ hg parents
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   $ hg debugbundle .hg/strip-backup/*
   Stream params: {Compression: BZ}
   changegroup -- {nbchanges: 1, version: 02}
       264128213d290d868c54642d13aeaa3675551a78
   cache:rev-branch-cache -- {}
   phase-heads -- {}
       264128213d290d868c54642d13aeaa3675551a78 draft
   $ hg unbundle .hg/strip-backup/*
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 1 files (+1 heads)
   new changesets 264128213d29
   (run 'hg heads' to see heads, 'hg merge' to merge)
   $ rm .hg/strip-backup/*
   $ hg log --graph
   o  changeset:   4:264128213d29
   |  tag:         tip
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   | o  changeset:   3:443431ffac4f
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     e
   | |
   | o  changeset:   2:65bd5f99a4a3
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     d
   |
   @  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ hg up -C 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 4
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
 
 before strip of merge parent
 
   $ hg parents
   changeset:   2:65bd5f99a4a3
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     d
   
   changeset:   4:264128213d29
   tag:         tip
   parent:      1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     c
   
   $ hg strip 4
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 after strip of merge parent
 
   $ hg parents
   changeset:   1:ef3a871183d7
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     b
   
   $ restore
 
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "264128213d29: c"
   1 other heads for branch "default"
   $ hg log -G
   @  changeset:   4:264128213d29
   |  tag:         tip
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   | o  changeset:   3:443431ffac4f
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     e
   | |
   | o  changeset:   2:65bd5f99a4a3
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     d
   |
   o  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 
 2 is parent of 3, only one strip should happen
 
   $ hg strip "roots(2)" 3
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg log -G
   @  changeset:   2:264128213d29
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     c
   |
   o  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ restore
   $ hg log -G
   o  changeset:   4:443431ffac4f
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     e
   |
   o  changeset:   3:65bd5f99a4a3
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     d
   |
   | @  changeset:   2:264128213d29
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     c
   |
   o  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 Failed hook while applying "saveheads" bundle.
 
   $ hg strip 2 --config hooks.pretxnchangegroup.bad=false
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   transaction abort!
   rollback completed
   strip failed, backup bundle stored in '$TESTTMP/test/.hg/strip-backup/*-backup.hg' (glob)
   strip failed, unrecovered changes stored in '$TESTTMP/test/.hg/strip-backup/*-temp.hg' (glob)
   (fix the problem, then recover the changesets with "hg unbundle '$TESTTMP/test/.hg/strip-backup/*-temp.hg'") (glob)
   abort: pretxnchangegroup.bad hook exited with status 1
   [255]
   $ restore
   $ hg log -G
   o  changeset:   4:443431ffac4f
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     e
   |
   o  changeset:   3:65bd5f99a4a3
   |  parent:      1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     d
   |
   | o  changeset:   2:264128213d29
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     c
   |
   @  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
 
 2 different branches: 2 strips
 
   $ hg strip 2 4
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg log -G
   o  changeset:   2:65bd5f99a4a3
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     d
   |
   @  changeset:   1:ef3a871183d7
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ restore
 
 2 different branches and a common ancestor: 1 strip
 
   $ hg strip 1 "2|4"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ restore
 
 verify fncache is kept up-to-date
 
   $ touch a
   $ hg ci -qAm a
+#if repofncache
   $ cat .hg/store/fncache | sort
   data/a.i
   data/bar.i
+#endif
 
   $ hg strip tip
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
+#if repofncache
   $ cat .hg/store/fncache
   data/bar.i
+#endif
 
 stripping an empty revset
 
   $ hg strip "1 and not 1"
   abort: empty revision set
   [255]
 
 remove branchy history for qimport tests
 
   $ hg strip 3
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 
 strip of applied mq should cleanup status file
 
   $ echo "mq=" >> $HGRCPATH
   $ hg up -C 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo fooagain >> bar
   $ hg ci -mf
   $ hg qimport -r tip:2
 
 applied patches before strip
 
   $ hg qapplied
   d
   e
   f
 
 stripping revision in queue
 
   $ hg strip 3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 applied patches after stripping rev in queue
 
   $ hg qapplied
   d
 
 stripping ancestor of queue
 
   $ hg strip 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
 
 applied patches after stripping ancestor of queue
 
   $ hg qapplied
 
 Verify strip protects against stripping wc parent when there are uncommitted mods
 
   $ echo b > b
   $ echo bb > bar
   $ hg add b
   $ hg ci -m 'b'
   $ hg log --graph
   @  changeset:   1:76dcf9fab855
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     b
   |
   o  changeset:   0:9ab35a2d17cb
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ hg up 0
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo c > bar
   $ hg up -t false
   merging bar
   merging bar failed!
   1 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   [1]
   $ hg sum
   parent: 1:76dcf9fab855 tip
    b
   branch: default
   commit: 1 modified, 1 unknown, 1 unresolved
   update: (current)
   phases: 2 draft
   mq:     3 unapplied
 
   $ echo c > b
   $ hg strip tip
   abort: local changes found
   [255]
   $ hg strip tip --keep
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg log --graph
   @  changeset:   0:9ab35a2d17cb
      tag:         tip
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     a
   
   $ hg status
   M bar
   ? b
   ? bar.orig
 
   $ rm bar.orig
   $ hg sum
   parent: 0:9ab35a2d17cb tip
    a
   branch: default
   commit: 1 modified, 1 unknown
   update: (current)
   phases: 1 draft
   mq:     3 unapplied
 
 Strip adds, removes, modifies with --keep
 
   $ touch b
   $ hg add b
   $ hg commit -mb
   $ touch c
 
 ... with a clean working dir
 
   $ hg add c
   $ hg rm bar
   $ hg commit -mc
   $ hg status
   $ hg strip --keep tip
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg status
   ! bar
   ? c
 
 ... with a dirty working dir
 
   $ hg add c
   $ hg rm bar
   $ hg commit -mc
   $ hg status
   $ echo b > b
   $ echo d > d
   $ hg strip --keep tip
   saved backup bundle to $TESTTMP/test/.hg/strip-backup/*-backup.hg (glob)
   $ hg status
   M b
   ! bar
   ? c
   ? d
 
 ... after updating the dirstate
   $ hg add c
   $ hg commit -mc
   $ hg rm c
   $ hg commit -mc
   $ hg strip --keep '.^' -q
   $ cd ..
 
 stripping many nodes on a complex graph (issue3299)
 
   $ hg init issue3299
   $ cd issue3299
   $ hg debugbuilddag '@a.:a@b.:b.:x<a@a.:a<b@b.:b<a@a.:a'
   $ hg strip 'not ancestors(x)'
   saved backup bundle to $TESTTMP/issue3299/.hg/strip-backup/*-backup.hg (glob)
 
 test hg strip -B bookmark
 
   $ cd ..
   $ hg init bookmarks
   $ cd bookmarks
   $ hg debugbuilddag '..<2.*1/2:m<2+3:c<m+3:a<2.:b<m+2:d<2.:e<m+1:f'
   $ hg bookmark -r 'a' 'todelete'
   $ hg bookmark -r 'b' 'B'
   $ hg bookmark -r 'b' 'nostrip'
   $ hg bookmark -r 'c' 'delete'
   $ hg bookmark -r 'd' 'multipledelete1'
   $ hg bookmark -r 'e' 'multipledelete2'
   $ hg bookmark -r 'f' 'singlenode1'
   $ hg bookmark -r 'f' 'singlenode2'
   $ hg up -C todelete
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark todelete)
   $ hg strip -B nostrip
   bookmark 'nostrip' deleted
   abort: empty revision set
   [255]
   $ hg strip -B todelete
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/*-backup.hg (glob)
   bookmark 'todelete' deleted
   $ hg id -ir dcbb326fdec2
   abort: unknown revision 'dcbb326fdec2'!
   [255]
   $ hg id -ir d62d843c9a01
   d62d843c9a01
   $ hg bookmarks
      B                         9:ff43616e5d0f
      delete                    6:2702dd0c91e7
      multipledelete1           11:e46a4836065c
      multipledelete2           12:b4594d867745
      singlenode1               13:43227190fef8
      singlenode2               13:43227190fef8
   $ hg strip -B multipledelete1 -B multipledelete2
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/e46a4836065c-89ec65c2-backup.hg
   bookmark 'multipledelete1' deleted
   bookmark 'multipledelete2' deleted
   $ hg id -ir e46a4836065c
   abort: unknown revision 'e46a4836065c'!
   [255]
   $ hg id -ir b4594d867745
   abort: unknown revision 'b4594d867745'!
   [255]
   $ hg strip -B singlenode1 -B singlenode2
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/43227190fef8-8da858f2-backup.hg
   bookmark 'singlenode1' deleted
   bookmark 'singlenode2' deleted
   $ hg id -ir 43227190fef8
   abort: unknown revision '43227190fef8'!
   [255]
   $ hg strip -B unknownbookmark
   abort: bookmark 'unknownbookmark' not found
   [255]
   $ hg strip -B unknownbookmark1 -B unknownbookmark2
   abort: bookmark 'unknownbookmark1,unknownbookmark2' not found
   [255]
   $ hg strip -B delete -B unknownbookmark
   abort: bookmark 'unknownbookmark' not found
   [255]
   $ hg strip -B delete
   saved backup bundle to $TESTTMP/bookmarks/.hg/strip-backup/*-backup.hg (glob)
   bookmark 'delete' deleted
   $ hg id -ir 6:2702dd0c91e7
   abort: unknown revision '2702dd0c91e7'!
   [255]
   $ hg update B
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (activating bookmark B)
   $ echo a > a
   $ hg add a
   $ hg strip -B B
   abort: local changes found
   [255]
   $ hg bookmarks
    * B                         6:ff43616e5d0f
 
 Make sure no one adds back a -b option:
 
   $ hg strip -b tip
   hg strip: option -b not recognized
   hg strip [-k] [-f] [-B bookmark] [-r] REV...
   
   strip changesets and all their descendants from the repository
   
   (use 'hg help -e strip' to show help for the strip extension)
   
   options ([+] can be repeated):
   
    -r --rev REV [+]        strip specified revision (optional, can specify
                            revisions without this option)
    -f --force              force removal of changesets, discard uncommitted
                            changes (no backup)
       --no-backup          no backups
    -k --keep               do not modify working directory during strip
    -B --bookmark VALUE [+] remove revs only reachable from given bookmark
       --mq                 operate on patch repository
   
   (use 'hg strip -h' to show more help)
   [255]
 
   $ cd ..
 
 Verify bundles don't get overwritten:
 
   $ hg init doublebundle
   $ cd doublebundle
   $ touch a
   $ hg commit -Aqm a
   $ touch b
   $ hg commit -Aqm b
   $ hg strip -r 0
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/doublebundle/.hg/strip-backup/3903775176ed-e68910bd-backup.hg
   $ ls .hg/strip-backup
   3903775176ed-e68910bd-backup.hg
   $ hg pull -q -r 3903775176ed .hg/strip-backup/3903775176ed-e68910bd-backup.hg
   $ hg strip -r 0
   saved backup bundle to $TESTTMP/doublebundle/.hg/strip-backup/3903775176ed-54390173-backup.hg
   $ ls .hg/strip-backup
   3903775176ed-54390173-backup.hg
   3903775176ed-e68910bd-backup.hg
   $ cd ..
 
 Test that we only bundle the stripped changesets (issue4736)
 ------------------------------------------------------------
 
 initialization (previous repo is empty anyway)
 
   $ hg init issue4736
   $ cd issue4736
   $ echo a > a
   $ hg add a
   $ hg commit -m commitA
   $ echo b > b
   $ hg add b
   $ hg commit -m commitB
   $ echo c > c
   $ hg add c
   $ hg commit -m commitC
   $ hg up 'desc(commitB)'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo d > d
   $ hg add d
   $ hg commit -m commitD
   created new head
   $ hg up 'desc(commitC)'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 'desc(commitD)'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'mergeCD'
   $ hg log -G
   @    changeset:   4:d8db9d137221
   |\   tag:         tip
   | |  parent:      2:5c51d8d6557d
   | |  parent:      3:6625a5168474
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     mergeCD
   | |
   | o  changeset:   3:6625a5168474
   | |  parent:      1:eca11cf91c71
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     commitD
   | |
   o |  changeset:   2:5c51d8d6557d
   |/   user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     commitC
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
 Check bundle behavior:
 
   $ hg bundle -r 'desc(mergeCD)' --base 'desc(commitC)' ../issue4736.hg
   2 changesets found
   $ hg log -r 'bundle()' -R ../issue4736.hg
   changeset:   3:6625a5168474
   parent:      1:eca11cf91c71
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commitD
   
   changeset:   4:d8db9d137221
   tag:         tip
   parent:      2:5c51d8d6557d
   parent:      3:6625a5168474
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     mergeCD
   
 
 check strip behavior
 
   $ hg --config extensions.strip= strip 'desc(commitD)' --debug
   resolving manifests
    branchmerge: False, force: True, partial: False
    ancestor: d8db9d137221+, local: d8db9d137221+, remote: eca11cf91c71
    c: other deleted -> r
   removing c
    d: other deleted -> r
   removing d
   starting 4 threads for background file closing (?)
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   2 changesets found
   list of changesets:
   6625a516847449b6f0fa3737b9ba56e9f0f3032c
   d8db9d1372214336d2b5570f20ee468d2c72fa8b
   bundle2-output-bundle: "HG20", (1 params) 3 parts total
   bundle2-output-part: "changegroup" (params: 1 mandatory 1 advisory) streamed payload
   bundle2-output-part: "cache:rev-branch-cache" streamed payload
   bundle2-output-part: "phase-heads" 24 bytes payload
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/6625a5168474-345bb43d-backup.hg
   updating the branch cache
   invalid branchheads cache (served): tip differs
   $ hg log -G
   o  changeset:   2:5c51d8d6557d
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitC
   |
   @  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
 strip backup content
 
   $ hg log -r 'bundle()' -R .hg/strip-backup/6625a5168474-*-backup.hg
   changeset:   3:6625a5168474
   parent:      1:eca11cf91c71
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     commitD
   
   changeset:   4:d8db9d137221
   tag:         tip
   parent:      2:5c51d8d6557d
   parent:      3:6625a5168474
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     mergeCD
   
 Check that the phase cache is properly invalidated after a strip with bookmark.
 
   $ cat > ../stripstalephasecache.py << EOF
   > from mercurial import extensions, localrepo
   > def transactioncallback(orig, repo, desc, *args, **kwargs):
   >     def test(transaction):
   >         # observe cache inconsistency
   >         try:
   >             [repo.changelog.node(r) for r in repo.revs(b"not public()")]
   >         except IndexError:
   >             repo.ui.status(b"Index error!\n")
   >     transaction = orig(repo, desc, *args, **kwargs)
   >     # warm up the phase cache
   >     list(repo.revs(b"not public()"))
   >     if desc != b'strip':
   >          transaction.addpostclose(b"phase invalidation test", test)
   >     return transaction
   > def extsetup(ui):
   >     extensions.wrapfunction(localrepo.localrepository, b"transaction",
   >                             transactioncallback)
   > EOF
   $ hg up -C 2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo k > k
   $ hg add k
   $ hg commit -m commitK
   $ echo l > l
   $ hg add l
   $ hg commit -m commitL
   $ hg book -r tip blah
   $ hg strip ".^" --config extensions.crash=$TESTTMP/stripstalephasecache.py
   0 files updated, 0 files merged, 2 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/8f0b4384875c-4fa10deb-backup.hg
   $ hg up -C 1
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 Error during post-close callback of the strip transaction
 (They should be gracefully handled and reported)
 
   $ cat > ../crashstrip.py << EOF
   > from mercurial import error
   > def reposetup(ui, repo):
   >     class crashstriprepo(repo.__class__):
   >         def transaction(self, desc, *args, **kwargs):
   >             tr = super(crashstriprepo, self).transaction(desc, *args, **kwargs)
   >             if desc == b'strip':
   >                 def crash(tra): raise error.Abort(b'boom')
   >                 tr.addpostclose(b'crash', crash)
   >             return tr
   >     repo.__class__ = crashstriprepo
   > EOF
   $ hg strip tip --config extensions.crash=$TESTTMP/crashstrip.py
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/5c51d8d6557d-70daef06-backup.hg
   strip failed, backup bundle stored in '$TESTTMP/issue4736/.hg/strip-backup/5c51d8d6557d-70daef06-backup.hg'
   abort: boom
   [255]
 
 test stripping a working directory parent doesn't switch named branches
 
   $ hg log -G
   @  changeset:   1:eca11cf91c71
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
   $ hg branch new-branch
   marked working directory as branch new-branch
   (branches are permanent and global, did you want a bookmark?)
   $ hg ci -m "start new branch"
   $ echo 'foo' > foo.txt
   $ hg ci -Aqm foo
   $ hg up default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'bar' > bar.txt
   $ hg ci -Aqm bar
   $ hg up new-branch
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg log -G
   @  changeset:   4:35358f982181
   |  tag:         tip
   |  parent:      1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     bar
   |
   | @  changeset:   3:f62c6c09b707
   | |  branch:      new-branch
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     foo
   | |
   | o  changeset:   2:b1d33a8cadd9
   |/   branch:      new-branch
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     start new branch
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
   $ hg strip --force -r 35358f982181
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/35358f982181-50d992d4-backup.hg
   $ hg log -G
   @  changeset:   3:f62c6c09b707
   |  branch:      new-branch
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     foo
   |
   o  changeset:   2:b1d33a8cadd9
   |  branch:      new-branch
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     start new branch
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
   $ hg up default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'bar' > bar.txt
   $ hg ci -Aqm bar
   $ hg up new-branch
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m merge
   $ hg log -G
   @    changeset:   5:4cf5e92caec2
   |\   branch:      new-branch
   | |  tag:         tip
   | |  parent:      3:f62c6c09b707
   | |  parent:      4:35358f982181
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     merge
   | |
   | o  changeset:   4:35358f982181
   | |  parent:      1:eca11cf91c71
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     bar
   | |
   o |  changeset:   3:f62c6c09b707
   | |  branch:      new-branch
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     foo
   | |
   o |  changeset:   2:b1d33a8cadd9
   |/   branch:      new-branch
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     start new branch
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
   $ hg strip -r 35358f982181
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/35358f982181-a6f020aa-backup.hg
   $ hg log -G
   @  changeset:   3:f62c6c09b707
   |  branch:      new-branch
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     foo
   |
   o  changeset:   2:b1d33a8cadd9
   |  branch:      new-branch
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     start new branch
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
 
   $ hg unbundle -u $TESTTMP/issue4736/.hg/strip-backup/35358f982181-a6f020aa-backup.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 1 changes to 1 files
   new changesets 35358f982181:4cf5e92caec2
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg strip -k -r 35358f982181
   saved backup bundle to $TESTTMP/issue4736/.hg/strip-backup/35358f982181-a6f020aa-backup.hg
   $ hg log -G
   @  changeset:   3:f62c6c09b707
   |  branch:      new-branch
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     foo
   |
   o  changeset:   2:b1d33a8cadd9
   |  branch:      new-branch
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     start new branch
   |
   o  changeset:   1:eca11cf91c71
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     commitB
   |
   o  changeset:   0:105141ef12d0
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     commitA
   
   $ hg diff
   diff -r f62c6c09b707 bar.txt
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/bar.txt	Thu Jan 01 00:00:00 1970 +0000
   @@ -0,0 +1,1 @@
   +bar
 
 Use delayedstrip to strip inside a transaction
 
   $ cd $TESTTMP
   $ hg init delayedstrip
   $ cd delayedstrip
   $ hg debugdrawdag <<'EOS'
   >   D
   >   |
   >   C F H    # Commit on top of "I",
   >   | |/|    # Strip B+D+I+E+G+H+Z
   > I B E G
   >  \|/
   >   A   Z
   > EOS
   $ cp -R . ../scmutilcleanup
 
   $ hg up -C I
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 3 >> I
   $ cat > $TESTTMP/delayedstrip.py <<EOF
   > from __future__ import absolute_import
   > from mercurial import commands, registrar, repair
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'testdelayedstrip')
   > def testdelayedstrip(ui, repo):
   >     def getnodes(expr):
   >         return [repo.changelog.node(r) for r in repo.revs(expr)]
   >     with repo.wlock():
   >         with repo.lock():
   >             with repo.transaction(b'delayedstrip'):
   >                 repair.delayedstrip(ui, repo, getnodes(b'B+I+Z+D+E'), b'J')
   >                 repair.delayedstrip(ui, repo, getnodes(b'G+H+Z'), b'I')
   >                 commands.commit(ui, repo, message=b'J', date=b'0 0')
   > EOF
   $ hg testdelayedstrip --config extensions.t=$TESTTMP/delayedstrip.py
   warning: orphaned descendants detected, not stripping 08ebfeb61bac, 112478962961, 7fb047a69f22
   saved backup bundle to $TESTTMP/delayedstrip/.hg/strip-backup/f585351a92f8-17475721-I.hg
 
   $ hg log -G -T '{rev}:{node|short} {desc}' -r 'sort(all(), topo)'
   @  6:2f2d51af6205 J
   |
   o  3:08ebfeb61bac I
   |
   | o  5:64a8289d2492 F
   | |
   | o  2:7fb047a69f22 E
   |/
   | o  4:26805aba1e60 C
   | |
   | o  1:112478962961 B
   |/
   o  0:426bada5c675 A
   
 Test high-level scmutil.cleanupnodes API
 
   $ cd $TESTTMP/scmutilcleanup
   $ hg debugdrawdag <<'EOS'
   >   D2  F2  G2   # D2, F2, G2 are replacements for D, F, G
   >   |   |   |
   >   C   H   G
   > EOS
   $ for i in B C D F G I Z; do
   >     hg bookmark -i -r $i b-$i
   > done
   $ hg bookmark -i -r E 'b-F@divergent1'
   $ hg bookmark -i -r H 'b-F@divergent2'
   $ hg bookmark -i -r G 'b-F@divergent3'
   $ cp -R . ../scmutilcleanup.obsstore
 
   $ cat > $TESTTMP/scmutilcleanup.py <<EOF
   > from mercurial import registrar, scmutil
   > cmdtable = {}
   > command = registrar.command(cmdtable)
   > @command(b'testnodescleanup')
   > def testnodescleanup(ui, repo):
   >     def nodes(expr):
   >         return [repo.changelog.node(r) for r in repo.revs(expr)]
   >     def node(expr):
   >         return nodes(expr)[0]
   >     with repo.wlock():
   >         with repo.lock():
   >             with repo.transaction(b'delayedstrip'):
   >                 mapping = {node(b'F'): [node(b'F2')],
   >                            node(b'D'): [node(b'D2')],
   >                            node(b'G'): [node(b'G2')]}
   >                 scmutil.cleanupnodes(repo, mapping, b'replace')
   >                 scmutil.cleanupnodes(repo, nodes(b'((B::)+I+Z)-D2'),
   >                                      b'replace')
   > EOF
   $ hg testnodescleanup --config extensions.t=$TESTTMP/scmutilcleanup.py
   warning: orphaned descendants detected, not stripping 112478962961, 1fc8102cda62, 26805aba1e60
   saved backup bundle to $TESTTMP/scmutilcleanup/.hg/strip-backup/f585351a92f8-73fb7c03-replace.hg
 
   $ hg log -G -T '{rev}:{node|short} {desc} {bookmarks}' -r 'sort(all(), topo)'
   o  8:1473d4b996d1 G2 b-F@divergent3 b-G
   |
   | o  7:d11b3456a873 F2 b-F
   | |
   | o  5:5cb05ba470a7 H
   |/|
   | o  3:7fb047a69f22 E b-F@divergent1
   | |
   | | o  6:7c78f703e465 D2 b-D
   | | |
   | | o  4:26805aba1e60 C
   | | |
   | | o  2:112478962961 B
   | |/
   o |  1:1fc8102cda62 G
    /
   o  0:426bada5c675 A b-B b-C b-I
   
   $ hg bookmark
      b-B                       0:426bada5c675
      b-C                       0:426bada5c675
      b-D                       6:7c78f703e465
      b-F                       7:d11b3456a873
      b-F@divergent1            3:7fb047a69f22
      b-F@divergent3            8:1473d4b996d1
      b-G                       8:1473d4b996d1
      b-I                       0:426bada5c675
      b-Z                       -1:000000000000
 
 Test the above using obsstore "by the way". Not directly related to strip, but
 we have reusable code here
 
   $ cd $TESTTMP/scmutilcleanup.obsstore
   $ cat >> .hg/hgrc <<EOF
   > [experimental]
   > evolution=true
   > evolution.track-operation=1
   > EOF
 
   $ hg testnodescleanup --config extensions.t=$TESTTMP/scmutilcleanup.py
   4 new orphan changesets
 
   $ rm .hg/localtags
   $ hg log -G -T '{rev}:{node|short} {desc} {bookmarks}' -r 'sort(all(), topo)'
   *  12:1473d4b996d1 G2 b-F@divergent3 b-G
   |
   | *  11:d11b3456a873 F2 b-F
   | |
   | *  8:5cb05ba470a7 H
   |/|
   | o  4:7fb047a69f22 E b-F@divergent1
   | |
   | | *  10:7c78f703e465 D2 b-D
   | | |
   | | x  6:26805aba1e60 C
   | | |
   | | x  3:112478962961 B
   | |/
   x |  1:1fc8102cda62 G
    /
   o  0:426bada5c675 A b-B b-C b-I
   
   $ hg debugobsolete
   1fc8102cda6204549f031015641606ccf5513ec3 1473d4b996d1d1b121de6b39fab6a04fbf9d873e 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '13', 'operation': 'replace', 'user': 'test'}
   64a8289d249234b9886244d379f15e6b650b28e3 d11b3456a873daec7c7bc53e5622e8df6d741bd2 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '13', 'operation': 'replace', 'user': 'test'}
   f585351a92f85104bff7c284233c338b10eb1df7 7c78f703e465d73102cc8780667ce269c5208a40 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '9', 'operation': 'replace', 'user': 'test'}
   48b9aae0607f43ff110d84e6883c151942add5ab 0 {0000000000000000000000000000000000000000} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'replace', 'user': 'test'}
   112478962961147124edd43549aedd1a335e44bf 0 {426bada5c67598ca65036d57d9e4b64b0c1ce7a0} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'replace', 'user': 'test'}
   08ebfeb61bac6e3f12079de774d285a0d6689eba 0 {426bada5c67598ca65036d57d9e4b64b0c1ce7a0} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'replace', 'user': 'test'}
   26805aba1e600a82e93661149f2313866a221a7b 0 {112478962961147124edd43549aedd1a335e44bf} (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '0', 'operation': 'replace', 'user': 'test'}
   $ cd ..
 
 Test that obsmarkers are restored even when not using generaldelta
 
   $ hg --config format.usegeneraldelta=no init issue5678
   $ cd issue5678
   $ cat >> .hg/hgrc <<EOF
   > [experimental]
   > evolution=true
   > EOF
   $ echo a > a
   $ hg ci -Aqm a
   $ hg ci --amend -m a2
   $ hg debugobsolete
   cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b 489bac576828490c0bb8d45eac9e5e172e4ec0a8 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '1', 'operation': 'amend', 'user': 'test'}
   $ hg strip .
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/issue5678/.hg/strip-backup/489bac576828-bef27e14-backup.hg
   $ hg unbundle -q .hg/strip-backup/*
   $ hg debugobsolete
   cb9a9f314b8b07ba71012fcdbc544b5a4d82ff5b 489bac576828490c0bb8d45eac9e5e172e4ec0a8 0 (Thu Jan 01 00:00:00 1970 +0000) {'ef1': '1', 'operation': 'amend', 'user': 'test'}
   $ cd ..

tests/test-subrepo-deep-nested-change.t

@@ -1,1211 +1,1205 b''
   $ cat >> $HGRCPATH <<EOF
   > [extdiff]
   > # for portability:
   > pdiff = sh "$RUNTESTDIR/pdiff"
   > [progress]
   > disable=False
   > assume-tty = 1
   > delay = 0
   > # set changedelay really large so we don't see nested topics
   > changedelay = 30000
   > format = topic bar number
   > refresh = 0
   > width = 60
   > EOF
 
 Preparing the subrepository 'sub2'
 
   $ hg init sub2
   $ echo sub2 > sub2/sub2
   $ hg add -R sub2
   adding sub2/sub2
   $ hg commit -R sub2 -m "sub2 import"
 
 Preparing the 'sub1' repo which depends on the subrepo 'sub2'
 
   $ hg init sub1
   $ echo sub1 > sub1/sub1
   $ echo "sub2 = ../sub2" > sub1/.hgsub
   $ hg clone sub2 sub1/sub2
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
-  linking [       <=>                                     ] 7\r (no-eol) (esc) (reposimplestore !)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg add -R sub1
   adding sub1/.hgsub
   adding sub1/sub1
   $ hg commit -R sub1 -m "sub1 import"
 
 Preparing the 'main' repo which depends on the subrepo 'sub1'
 
   $ hg init main
   $ echo main > main/main
   $ echo "sub1 = ../sub1" > main/.hgsub
   $ hg clone sub1 main/sub1
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
   linking [       <=>                                     ] 7\r (no-eol) (esc)
   linking [        <=>                                    ] 8\r (no-eol) (esc)
   linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
   linking [          <=>                                 ] 10\r (no-eol) (esc) (reposimplestore !)
-  linking [           <=>                                ] 11\r (no-eol) (esc) (reposimplestore !)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
-  linking [       <=>                                     ] 7\r (no-eol) (esc) (reposimplestore !)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   updating to branch default
   cloning subrepo sub2 from $TESTTMP/sub2
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg add -R main
   adding main/.hgsub
   adding main/main
   $ hg commit -R main -m "main import"
 
 #if serve
 
 Unfortunately, subrepos not at their nominal location cannot be cloned.  But
 they are still served from their location within the local repository.  The only
 reason why 'main' can be cloned via the filesystem is because 'sub1' and 'sub2'
 are also available as siblings of 'main'.
 
   $ hg serve -R main --debug -S -p $HGPORT -d --pid-file=hg1.pid -E error.log -A access.log
   adding  = $TESTTMP/main
   adding sub1 = $TESTTMP/main/sub1
   adding sub1/sub2 = $TESTTMP/main/sub1/sub2
   listening at http://*:$HGPORT/ (bound to *:$HGPORT) (glob) (?)
   adding  = $TESTTMP/main (?)
   adding sub1 = $TESTTMP/main/sub1 (?)
   adding sub1/sub2 = $TESTTMP/main/sub1/sub2 (?)
   $ cat hg1.pid >> $DAEMON_PIDS
 
   $ hg clone http://localhost:$HGPORT httpclone --config progress.disable=True
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 3 changes to 3 files
   new changesets 7f491f53a367
   updating to branch default
   abort: HTTP Error 404: Not Found
   [255]
 
   $ cat access.log
   * "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   * "GET /?cmd=batch HTTP/1.1" 200 - * (glob)
   * "GET /?cmd=getbundle HTTP/1.1" 200 - * (glob)
   * "GET /../sub1?cmd=capabilities HTTP/1.1" 404 - (glob)
   $ cat error.log
 
   $ killdaemons.py
   $ rm hg1.pid error.log access.log
 #endif
 
 Cleaning both repositories, just as a clone -U
 
   $ hg up -C -R sub2 null
   \r (no-eol) (esc)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg up -C -R sub1 null
   \r (no-eol) (esc)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ hg up -C -R main null
   \r (no-eol) (esc)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ rm -rf main/sub1
   $ rm -rf sub1/sub2
 
 Clone main
 
   $ hg --config extensions.largefiles= clone main cloned
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
   linking [       <=>                                     ] 7\r (no-eol) (esc)
   linking [        <=>                                    ] 8\r (no-eol) (esc)
   linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
   linking [          <=>                                 ] 10\r (no-eol) (esc) (reposimplestore !)
-  linking [           <=>                                ] 11\r (no-eol) (esc) (reposimplestore !)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
   linking [       <=>                                     ] 7\r (no-eol) (esc)
   linking [        <=>                                    ] 8\r (no-eol) (esc)
   linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
   linking [          <=>                                 ] 10\r (no-eol) (esc) (reposimplestore !)
-  linking [           <=>                                ] 11\r (no-eol) (esc) (reposimplestore !)
   updating [===========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   linking [         <=>                                   ] 1\r (no-eol) (esc) (no-reposimplestore !)
   linking [          <=>                                  ] 2\r (no-eol) (esc) (no-reposimplestore !)
   linking [           <=>                                 ] 3\r (no-eol) (esc) (no-reposimplestore !)
   linking [            <=>                                ] 4\r (no-eol) (esc) (no-reposimplestore !)
   linking [             <=>                               ] 5\r (no-eol) (esc) (no-reposimplestore !)
   linking [              <=>                              ] 6\r (no-eol) (esc) (no-reposimplestore !)
   linking [            <=>                                ] 1\r (no-eol) (esc) (reposimplestore !)
   linking [             <=>                               ] 2\r (no-eol) (esc) (reposimplestore !)
   linking [              <=>                              ] 3\r (no-eol) (esc) (reposimplestore !)
   linking [               <=>                             ] 4\r (no-eol) (esc) (reposimplestore !)
   linking [                <=>                            ] 5\r (no-eol) (esc) (reposimplestore !)
   linking [                 <=>                           ] 6\r (no-eol) (esc) (reposimplestore !)
-  linking [                  <=>                          ] 7\r (no-eol) (esc) (reposimplestore !)
   updating [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   updating to branch default
   cloning subrepo sub1 from $TESTTMP/sub1
   cloning subrepo sub1/sub2 from $TESTTMP/sub2
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 Largefiles is NOT enabled in the clone if the source repo doesn't require it
   $ cat cloned/.hg/hgrc
   # example repository config (see 'hg help config' for more info)
   [paths]
   default = $TESTTMP/main
   
   # 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]>
 
 Checking cloned repo ids
 
   $ printf "cloned " ; hg id -R cloned
   cloned 7f491f53a367 tip
   $ printf "cloned/sub1 " ; hg id -R cloned/sub1
   cloned/sub1 fc3b4ce2696f tip
   $ printf "cloned/sub1/sub2 " ; hg id -R cloned/sub1/sub2
   cloned/sub1/sub2 c57a0840e3ba tip
 
 debugsub output for main and sub1
 
   $ hg debugsub -R cloned
   path sub1
    source   ../sub1
    revision fc3b4ce2696f7741438c79207583768f2ce6b0dd
   $ hg debugsub -R cloned/sub1
   path sub2
    source   ../sub2
    revision c57a0840e3badd667ef3c3ef65471609acb2ba3c
 
 Modifying deeply nested 'sub2'
 
   $ echo modified > cloned/sub1/sub2/sub2
   $ hg commit --subrepos -m "deep nested modif should trigger a commit" -R cloned
   committing subrepository sub1
   committing subrepository sub1/sub2
 
 Checking modified node ids
 
   $ printf "cloned " ; hg id -R cloned
   cloned ffe6649062fe tip
   $ printf "cloned/sub1 " ; hg id -R cloned/sub1
   cloned/sub1 2ecb03bf44a9 tip
   $ printf "cloned/sub1/sub2 " ; hg id -R cloned/sub1/sub2
   cloned/sub1/sub2 53dd3430bcaf tip
 
 debugsub output for main and sub1
 
   $ hg debugsub -R cloned
   path sub1
    source   ../sub1
    revision 2ecb03bf44a94e749e8669481dd9069526ce7cb9
   $ hg debugsub -R cloned/sub1
   path sub2
    source   ../sub2
    revision 53dd3430bcaf5ab4a7c48262bcad6d441f510487
 
 Check that deep archiving works
 
   $ cd cloned
   $ echo 'test' > sub1/sub2/test.txt
   $ hg --config extensions.largefiles=! add sub1/sub2/test.txt
   $ mkdir sub1/sub2/folder
   $ echo 'subfolder' > sub1/sub2/folder/test.txt
   $ hg ci -ASm "add test.txt"
   adding sub1/sub2/folder/test.txt
   committing subrepository sub1
   committing subrepository sub1/sub2
 
   $ rm -r main
   $ hg archive -S -qr 'wdir()' ../wdir
   $ cat ../wdir/.hg_archival.txt
   repo: 7f491f53a367861f47ee64a80eb997d1f341b77a
   node: 9bb10eebee29dc0f1201dcf5977b811a540255fd+
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
   $ hg update -Cq .
 
 A deleted subrepo file is flagged as dirty, like the top level repo
 
   $ rm -r ../wdir sub1/sub2/folder/test.txt
   $ hg archive -S -qr 'wdir()' ../wdir
   $ cat ../wdir/.hg_archival.txt
   repo: 7f491f53a367861f47ee64a80eb997d1f341b77a
   node: 9bb10eebee29dc0f1201dcf5977b811a540255fd+
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
   $ hg update -Cq .
   $ rm -r ../wdir
 
   $ hg archive -S -qr 'wdir()' ../wdir \
   >            --config 'experimental.archivemetatemplate=archived {node|short}\n'
   $ cat ../wdir/.hg_archival.txt
   archived ffffffffffff
   $ rm -r ../wdir
 
 .. but first take a detour through some deep removal testing
 
   $ hg remove -S -I 're:.*.txt' .
   \r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [=====================>                      ] 1/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   removing sub1/sub2/folder/test.txt
   removing sub1/sub2/test.txt
   $ hg status -S
   R sub1/sub2/folder/test.txt
   R sub1/sub2/test.txt
   $ hg update -Cq
   $ hg remove -I 're:.*.txt' sub1
   \r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ hg status -S
   $ hg remove sub1/sub2/folder/test.txt
   \r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ hg remove sub1/.hgsubstate
   \r (no-eol) (esc)
   searching [==========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ mv sub1/.hgsub sub1/x.hgsub
   $ hg status -S
   warning: subrepo spec file 'sub1/.hgsub' not found
   R sub1/.hgsubstate
   R sub1/sub2/folder/test.txt
   ! sub1/.hgsub
   ? sub1/x.hgsub
   $ mv sub1/x.hgsub sub1/.hgsub
   $ hg update -Cq
   $ touch sub1/foo
   $ hg forget sub1/sub2/folder/test.txt
   $ rm sub1/sub2/test.txt
 
 Test relative path printing + subrepos
   $ mkdir -p foo/bar
   $ cd foo
   $ touch bar/abc
   $ hg addremove -S ..
   \r (no-eol) (esc)
   searching for exact renames [                         ] 0/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   adding ../sub1/sub2/folder/test.txt
   removing ../sub1/sub2/test.txt
   adding ../sub1/foo
   adding bar/abc
   $ cd ..
   $ hg status -S
   A foo/bar/abc
   A sub1/foo
   R sub1/sub2/test.txt
 
 Archive wdir() with subrepos
   $ hg rm main
   \r (no-eol) (esc)
   deleting [===========================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ hg archive -S -r 'wdir()' ../wdir
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/4\r (no-eol) (esc)
   archiving (sub1) [========>                           ] 1/4\r (no-eol) (esc)
   archiving (sub1) [=================>                  ] 2/4\r (no-eol) (esc)
   archiving (sub1) [==========================>         ] 3/4\r (no-eol) (esc)
   archiving (sub1) [===================================>] 4/4\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============>                ] 1/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ diff -r . ../wdir | egrep -v '\.hg$|^Common subdirectories:'
   Only in ../wdir: .hg_archival.txt
 
   $ find ../wdir -type f | sort
   ../wdir/.hg_archival.txt
   ../wdir/.hgsub
   ../wdir/.hgsubstate
   ../wdir/foo/bar/abc
   ../wdir/sub1/.hgsub
   ../wdir/sub1/.hgsubstate
   ../wdir/sub1/foo
   ../wdir/sub1/sub1
   ../wdir/sub1/sub2/folder/test.txt
   ../wdir/sub1/sub2/sub2
 
   $ cat ../wdir/.hg_archival.txt
   repo: 7f491f53a367861f47ee64a80eb997d1f341b77a
   node: 9bb10eebee29dc0f1201dcf5977b811a540255fd+
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
 
 Attempting to archive 'wdir()' with a missing file is handled gracefully
   $ rm sub1/sub1
   $ rm -r ../wdir
   $ hg archive -v -S -r 'wdir()' ../wdir
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/3\r (no-eol) (esc)
   archiving (sub1) [===========>                        ] 1/3\r (no-eol) (esc)
   archiving (sub1) [=======================>            ] 2/3\r (no-eol) (esc)
   archiving (sub1) [===================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============>                ] 1/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ find ../wdir -type f | sort
   ../wdir/.hg_archival.txt
   ../wdir/.hgsub
   ../wdir/.hgsubstate
   ../wdir/foo/bar/abc
   ../wdir/sub1/.hgsub
   ../wdir/sub1/.hgsubstate
   ../wdir/sub1/foo
   ../wdir/sub1/sub2/folder/test.txt
   ../wdir/sub1/sub2/sub2
 
 Continue relative path printing + subrepos
   $ hg update -Cq
   $ rm -r ../wdir
   $ hg archive -S -r 'wdir()' ../wdir
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/3\r (no-eol) (esc)
   archiving (sub1) [===========>                        ] 1/3\r (no-eol) (esc)
   archiving (sub1) [=======================>            ] 2/3\r (no-eol) (esc)
   archiving (sub1) [===================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/3\r (no-eol) (esc)
   archiving (sub1/sub2) [=========>                     ] 1/3\r (no-eol) (esc)
   archiving (sub1/sub2) [===================>           ] 2/3\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ cat ../wdir/.hg_archival.txt
   repo: 7f491f53a367861f47ee64a80eb997d1f341b77a
   node: 9bb10eebee29dc0f1201dcf5977b811a540255fd
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
 
   $ touch sub1/sub2/folder/bar
   $ hg addremove sub1/sub2
   adding sub1/sub2/folder/bar
   $ hg status -S
   A sub1/sub2/folder/bar
   ? foo/bar/abc
   ? sub1/foo
   $ hg update -Cq
   $ hg addremove sub1
   adding sub1/sub2/folder/bar
   adding sub1/foo
   $ hg update -Cq
   $ rm sub1/sub2/folder/test.txt
   $ rm sub1/sub2/test.txt
   $ hg ci -ASm "remove test.txt"
   adding sub1/sub2/folder/bar
   removing sub1/sub2/folder/test.txt
   removing sub1/sub2/test.txt
   adding sub1/foo
   adding foo/bar/abc
   committing subrepository sub1
   committing subrepository sub1/sub2
 
   $ hg forget sub1/sub2/sub2
   $ echo x > sub1/sub2/x.txt
   $ hg add sub1/sub2/x.txt
 
 Files sees uncommitted adds and removes in subrepos
   $ hg files -S
   .hgsub
   .hgsubstate
   foo/bar/abc
   main
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/foo
   sub1/sub1
   sub1/sub2/folder/bar
   sub1/sub2/x.txt
 
   $ hg files -S "set:eol('dos') or eol('unix') or size('<= 0')"
   .hgsub
   .hgsubstate
   foo/bar/abc
   main
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/foo
   sub1/sub1
   sub1/sub2/folder/bar
   sub1/sub2/x.txt
 
   $ hg files -r '.^' -S "set:eol('dos') or eol('unix')"
   .hgsub
   .hgsubstate
   main
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/sub1
   sub1/sub2/folder/test.txt
   sub1/sub2/sub2
   sub1/sub2/test.txt
 
   $ hg files sub1
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/foo
   sub1/sub1
   sub1/sub2/folder/bar
   sub1/sub2/x.txt
 
   $ hg files sub1/sub2
   sub1/sub2/folder/bar
   sub1/sub2/x.txt
 
   $ hg files
   .hgsub
   .hgsubstate
   foo/bar/abc
   main
 
   $ hg files -S -r '.^' sub1/sub2/folder
   sub1/sub2/folder/test.txt
 
   $ hg files -S -r '.^' sub1/sub2/missing
   sub1/sub2/missing: no such file in rev 78026e779ea6
   [1]
 
   $ hg files -r '.^' sub1/
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/sub1
   sub1/sub2/folder/test.txt
   sub1/sub2/sub2
   sub1/sub2/test.txt
 
   $ hg files -r '.^' sub1/sub2
   sub1/sub2/folder/test.txt
   sub1/sub2/sub2
   sub1/sub2/test.txt
 
   $ hg rollback -q
   $ hg up -Cq
 
   $ hg --config extensions.largefiles=! archive -S ../archive_all
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/3\r (no-eol) (esc)
   archiving (sub1) [===========>                        ] 1/3\r (no-eol) (esc)
   archiving (sub1) [=======================>            ] 2/3\r (no-eol) (esc)
   archiving (sub1) [===================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/3\r (no-eol) (esc)
   archiving (sub1/sub2) [=========>                     ] 1/3\r (no-eol) (esc)
   archiving (sub1/sub2) [===================>           ] 2/3\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ find ../archive_all | sort
   ../archive_all
   ../archive_all/.hg_archival.txt
   ../archive_all/.hgsub
   ../archive_all/.hgsubstate
   ../archive_all/main
   ../archive_all/sub1
   ../archive_all/sub1/.hgsub
   ../archive_all/sub1/.hgsubstate
   ../archive_all/sub1/sub1
   ../archive_all/sub1/sub2
   ../archive_all/sub1/sub2/folder
   ../archive_all/sub1/sub2/folder/test.txt
   ../archive_all/sub1/sub2/sub2
   ../archive_all/sub1/sub2/test.txt
 
 Check that archive -X works in deep subrepos
 
   $ hg --config extensions.largefiles=! archive -S -X '**test*' ../archive_exclude
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/3\r (no-eol) (esc)
   archiving (sub1) [===========>                        ] 1/3\r (no-eol) (esc)
   archiving (sub1) [=======================>            ] 2/3\r (no-eol) (esc)
   archiving (sub1) [===================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/1\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ find ../archive_exclude | sort
   ../archive_exclude
   ../archive_exclude/.hg_archival.txt
   ../archive_exclude/.hgsub
   ../archive_exclude/.hgsubstate
   ../archive_exclude/main
   ../archive_exclude/sub1
   ../archive_exclude/sub1/.hgsub
   ../archive_exclude/sub1/.hgsubstate
   ../archive_exclude/sub1/sub1
   ../archive_exclude/sub1/sub2
   ../archive_exclude/sub1/sub2/sub2
 
   $ hg --config extensions.largefiles=! archive -S -I '**test*' ../archive_include
   \r (no-eol) (esc)
   archiving (sub1) [ <=>                                  ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============>                ] 1/2\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ find ../archive_include | sort
   ../archive_include
   ../archive_include/sub1
   ../archive_include/sub1/sub2
   ../archive_include/sub1/sub2/folder
   ../archive_include/sub1/sub2/folder/test.txt
   ../archive_include/sub1/sub2/test.txt
 
 Check that deep archive works with largefiles (which overrides hgsubrepo impl)
 This also tests the repo.ui regression in 43fb170a23bd, and that lf subrepo
 subrepos are archived properly.
 Note that add --large through a subrepo currently adds the file as a normal file
 
   $ echo "large" > sub1/sub2/large.bin
   $ hg --config extensions.largefiles= add --large -R sub1/sub2 sub1/sub2/large.bin
   $ echo "large" > large.bin
   $ hg --config extensions.largefiles= add --large large.bin
   $ hg --config extensions.largefiles= ci -S -m "add large files"
   committing subrepository sub1
   committing subrepository sub1/sub2
 
   $ hg --config extensions.largefiles= archive -S ../archive_lf
   $ find ../archive_lf | sort
   ../archive_lf
   ../archive_lf/.hg_archival.txt
   ../archive_lf/.hgsub
   ../archive_lf/.hgsubstate
   ../archive_lf/large.bin
   ../archive_lf/main
   ../archive_lf/sub1
   ../archive_lf/sub1/.hgsub
   ../archive_lf/sub1/.hgsubstate
   ../archive_lf/sub1/sub1
   ../archive_lf/sub1/sub2
   ../archive_lf/sub1/sub2/folder
   ../archive_lf/sub1/sub2/folder/test.txt
   ../archive_lf/sub1/sub2/large.bin
   ../archive_lf/sub1/sub2/sub2
   ../archive_lf/sub1/sub2/test.txt
   $ rm -rf ../archive_lf
 
 Exclude large files from main and sub-sub repo
 
   $ hg --config extensions.largefiles= archive -S -X '**.bin' ../archive_lf
   $ find ../archive_lf | sort
   ../archive_lf
   ../archive_lf/.hg_archival.txt
   ../archive_lf/.hgsub
   ../archive_lf/.hgsubstate
   ../archive_lf/main
   ../archive_lf/sub1
   ../archive_lf/sub1/.hgsub
   ../archive_lf/sub1/.hgsubstate
   ../archive_lf/sub1/sub1
   ../archive_lf/sub1/sub2
   ../archive_lf/sub1/sub2/folder
   ../archive_lf/sub1/sub2/folder/test.txt
   ../archive_lf/sub1/sub2/sub2
   ../archive_lf/sub1/sub2/test.txt
   $ rm -rf ../archive_lf
 
 Exclude normal files from main and sub-sub repo
 
   $ hg --config extensions.largefiles= archive -S -X '**.txt' -p '.' ../archive_lf.tgz
   $ tar -tzf ../archive_lf.tgz | sort
   .hgsub
   .hgsubstate
   large.bin
   main
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/sub1
   sub1/sub2/large.bin
   sub1/sub2/sub2
 
 Include normal files from within a largefiles subrepo
 
   $ hg --config extensions.largefiles= archive -S -I '**.txt' ../archive_lf
   $ find ../archive_lf | sort
   ../archive_lf
   ../archive_lf/.hg_archival.txt
   ../archive_lf/sub1
   ../archive_lf/sub1/sub2
   ../archive_lf/sub1/sub2/folder
   ../archive_lf/sub1/sub2/folder/test.txt
   ../archive_lf/sub1/sub2/test.txt
   $ rm -rf ../archive_lf
 
 Include large files from within a largefiles subrepo
 
   $ hg --config extensions.largefiles= archive -S -I '**.bin' ../archive_lf
   $ find ../archive_lf | sort
   ../archive_lf
   ../archive_lf/large.bin
   ../archive_lf/sub1
   ../archive_lf/sub1/sub2
   ../archive_lf/sub1/sub2/large.bin
   $ rm -rf ../archive_lf
 
 Find an exact largefile match in a largefiles subrepo
 
   $ hg --config extensions.largefiles= archive -S -I 'sub1/sub2/large.bin' ../archive_lf
   $ find ../archive_lf | sort
   ../archive_lf
   ../archive_lf/sub1
   ../archive_lf/sub1/sub2
   ../archive_lf/sub1/sub2/large.bin
   $ rm -rf ../archive_lf
 
 The local repo enables largefiles if a largefiles repo is cloned
   $ hg showconfig extensions
   abort: repository requires features unknown to this Mercurial: largefiles!
   (see https://mercurial-scm.org/wiki/MissingRequirement for more information)
   [255]
   $ hg --config extensions.largefiles= clone -qU . ../lfclone
   $ cat ../lfclone/.hg/hgrc
   # example repository config (see 'hg help config' for more info)
   [paths]
   default = $TESTTMP/cloned
   
   # 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]>
   
   [extensions]
   largefiles=
 
 Find an exact match to a standin (should archive nothing)
   $ hg --config extensions.largefiles= archive -S -I 'sub/sub2/.hglf/large.bin' ../archive_lf
   $ find ../archive_lf 2> /dev/null | sort
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > largefiles=
   > [largefiles]
   > patterns=glob:**.dat
   > EOF
 
 Test forget through a deep subrepo with the largefiles extension, both a
 largefile and a normal file.  Then a largefile that hasn't been committed yet.
   $ touch sub1/sub2/untracked.txt
   $ touch sub1/sub2/large.dat
   $ hg forget sub1/sub2/large.bin sub1/sub2/test.txt sub1/sub2/untracked.txt
   not removing sub1/sub2/untracked.txt: file is already untracked
   [1]
   $ hg add --large --dry-run -v sub1/sub2/untracked.txt
   adding sub1/sub2/untracked.txt as a largefile
   $ hg add --large -v sub1/sub2/untracked.txt
   adding sub1/sub2/untracked.txt as a largefile
   $ hg add --normal -v sub1/sub2/large.dat
   adding sub1/sub2/large.dat
   $ hg forget -v sub1/sub2/untracked.txt
   removing sub1/sub2/untracked.txt
   $ hg status -S
   A sub1/sub2/large.dat
   R sub1/sub2/large.bin
   R sub1/sub2/test.txt
   ? foo/bar/abc
   ? sub1/sub2/untracked.txt
   ? sub1/sub2/x.txt
   $ hg add sub1/sub2
 
   $ hg archive -S -r 'wdir()' ../wdir2
   $ diff -r . ../wdir2 | egrep -v '\.hg$|^Common subdirectories:'
   Only in ../wdir2: .hg_archival.txt
   Only in .: .hglf
   Only in .: foo
   Only in ./sub1/sub2: large.bin
   Only in ./sub1/sub2: test.txt
   Only in ./sub1/sub2: untracked.txt
   Only in ./sub1/sub2: x.txt
   $ find ../wdir2 -type f | sort
   ../wdir2/.hg_archival.txt
   ../wdir2/.hgsub
   ../wdir2/.hgsubstate
   ../wdir2/large.bin
   ../wdir2/main
   ../wdir2/sub1/.hgsub
   ../wdir2/sub1/.hgsubstate
   ../wdir2/sub1/sub1
   ../wdir2/sub1/sub2/folder/test.txt
   ../wdir2/sub1/sub2/large.dat
   ../wdir2/sub1/sub2/sub2
   $ hg status -S -mac -n | sort
   .hgsub
   .hgsubstate
   large.bin
   main
   sub1/.hgsub
   sub1/.hgsubstate
   sub1/sub1
   sub1/sub2/folder/test.txt
   sub1/sub2/large.dat
   sub1/sub2/sub2
 
   $ hg ci -Sqm 'forget testing'
 
 Test 'wdir()' modified file archiving with largefiles
   $ echo 'mod' > main
   $ echo 'mod' > large.bin
   $ echo 'mod' > sub1/sub2/large.dat
   $ hg archive -S -r 'wdir()' ../wdir3
   $ diff -r . ../wdir3 | egrep -v '\.hg$|^Common subdirectories'
   Only in ../wdir3: .hg_archival.txt
   Only in .: .hglf
   Only in .: foo
   Only in ./sub1/sub2: large.bin
   Only in ./sub1/sub2: test.txt
   Only in ./sub1/sub2: untracked.txt
   Only in ./sub1/sub2: x.txt
   $ find ../wdir3 -type f | sort
   ../wdir3/.hg_archival.txt
   ../wdir3/.hgsub
   ../wdir3/.hgsubstate
   ../wdir3/large.bin
   ../wdir3/main
   ../wdir3/sub1/.hgsub
   ../wdir3/sub1/.hgsubstate
   ../wdir3/sub1/sub1
   ../wdir3/sub1/sub2/folder/test.txt
   ../wdir3/sub1/sub2/large.dat
   ../wdir3/sub1/sub2/sub2
   $ hg up -Cq
 
 Test issue4330: commit a directory where only normal files have changed
   $ touch foo/bar/large.dat
   $ hg add --large foo/bar/large.dat
   $ hg ci -m 'add foo/bar/large.dat'
   $ touch a.txt
   $ touch a.dat
   $ hg add -v foo/bar/abc a.txt a.dat
   adding a.dat as a largefile
   adding a.txt
   adding foo/bar/abc
   $ hg ci -m 'dir commit with only normal file deltas' foo/bar
   $ hg status
   A a.dat
   A a.txt
 
 Test a directory commit with a changed largefile and a changed normal file
   $ echo changed > foo/bar/large.dat
   $ echo changed > foo/bar/abc
   $ hg ci -m 'dir commit with normal and lf file deltas' foo
   $ hg status
   A a.dat
   A a.txt
 
   $ hg ci -m "add a.*"
   $ hg mv a.dat b.dat
   $ hg mv foo/bar/abc foo/bar/def
   $ hg status -C
   A b.dat
     a.dat
   A foo/bar/def
     foo/bar/abc
   R a.dat
   R foo/bar/abc
 
   $ hg ci -m "move large and normal"
   $ hg status -C --rev '.^' --rev .
   A b.dat
     a.dat
   A foo/bar/def
     foo/bar/abc
   R a.dat
   R foo/bar/abc
 
 
   $ echo foo > main
   $ hg ci -m "mod parent only"
   $ hg init sub3
   $ echo "sub3 = sub3" >> .hgsub
   $ echo xyz > sub3/a.txt
   $ hg add sub3/a.txt
   $ hg ci -Sm "add sub3"
   committing subrepository sub3
   $ cat .hgsub | grep -v sub3 > .hgsub1
   $ mv .hgsub1 .hgsub
   $ hg ci -m "remove sub3"
 
   $ hg log -r "subrepo()" --style compact
   0   7f491f53a367   1970-01-01 00:00 +0000   test
     main import
   
   1   ffe6649062fe   1970-01-01 00:00 +0000   test
     deep nested modif should trigger a commit
   
   2   9bb10eebee29   1970-01-01 00:00 +0000   test
     add test.txt
   
   3   7c64f035294f   1970-01-01 00:00 +0000   test
     add large files
   
   4   f734a59e2e35   1970-01-01 00:00 +0000   test
     forget testing
   
   11   9685a22af5db   1970-01-01 00:00 +0000   test
     add sub3
   
   12[tip]   2e0485b475b9   1970-01-01 00:00 +0000   test
     remove sub3
   
   $ hg log -r "subrepo('sub3')" --style compact
   11   9685a22af5db   1970-01-01 00:00 +0000   test
     add sub3
   
   12[tip]   2e0485b475b9   1970-01-01 00:00 +0000   test
     remove sub3
   
   $ hg log -r "subrepo('bogus')" --style compact
 
 
 Test .hgsubstate in the R state
 
   $ hg rm .hgsub .hgsubstate
   \r (no-eol) (esc)
   deleting [=====================>                      ] 1/2\r (no-eol) (esc)
   deleting [===========================================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ hg ci -m 'trash subrepo tracking'
 
   $ hg log -r "subrepo('re:sub\d+')" --style compact
   0   7f491f53a367   1970-01-01 00:00 +0000   test
     main import
   
   1   ffe6649062fe   1970-01-01 00:00 +0000   test
     deep nested modif should trigger a commit
   
   2   9bb10eebee29   1970-01-01 00:00 +0000   test
     add test.txt
   
   3   7c64f035294f   1970-01-01 00:00 +0000   test
     add large files
   
   4   f734a59e2e35   1970-01-01 00:00 +0000   test
     forget testing
   
   11   9685a22af5db   1970-01-01 00:00 +0000   test
     add sub3
   
   12   2e0485b475b9   1970-01-01 00:00 +0000   test
     remove sub3
   
   13[tip]   a68b2c361653   1970-01-01 00:00 +0000   test
     trash subrepo tracking
   
 
 Restore the trashed subrepo tracking
 
   $ hg rollback -q
   $ hg update -Cq .
 
 Interaction with extdiff, largefiles and subrepos
 
   $ hg --config extensions.extdiff= pdiff -S
 
   $ hg --config extensions.extdiff= pdiff -r '.^' -S
   \r (no-eol) (esc)
   archiving [                                           ] 0/2\r (no-eol) (esc)
   archiving [====================>                      ] 1/2\r (no-eol) (esc)
   archiving [==========================================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [ <=>                                  ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [ <=>                             ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub3) [ <=>                                  ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving [                                           ] 0/2\r (no-eol) (esc)
   archiving [====================>                      ] 1/2\r (no-eol) (esc)
   archiving [==========================================>] 2/2\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [ <=>                                  ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [ <=>                             ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   diff -Nru cloned.*/.hgsub cloned/.hgsub (glob)
   --- cloned.*/.hgsub	* (glob)
   +++ cloned/.hgsub	* (glob)
   @@ -1,2 +1* @@ (glob)
    sub1 = ../sub1
   -sub3 = sub3
   diff -Nru cloned.*/.hgsubstate cloned/.hgsubstate (glob)
   --- cloned.*/.hgsubstate	* (glob)
   +++ cloned/.hgsubstate	* (glob)
   @@ -1,2 +1* @@ (glob)
    7a36fa02b66e61f27f3d4a822809f159479b8ab2 sub1
   -b1a26de6f2a045a9f079323693614ee322f1ff7e sub3
   [1]
 
   $ hg --config extensions.extdiff= pdiff -r 0 -r '.^' -S
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/1\r (no-eol) (esc)
   archiving (sub1) [===================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/1\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving [                                           ] 0/8\r (no-eol) (esc)
   archiving [====>                                      ] 1/8\r (no-eol) (esc)
   archiving [=========>                                 ] 2/8\r (no-eol) (esc)
   archiving [===============>                           ] 3/8\r (no-eol) (esc)
   archiving [====================>                      ] 4/8\r (no-eol) (esc)
   archiving [=========================>                 ] 5/8\r (no-eol) (esc)
   archiving [===============================>           ] 6/8\r (no-eol) (esc)
   archiving [====================================>      ] 7/8\r (no-eol) (esc)
   archiving [==========================================>] 8/8\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1) [                                    ] 0/1\r (no-eol) (esc)
   archiving (sub1) [===================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/3\r (no-eol) (esc)
   archiving (sub1/sub2) [=========>                     ] 1/3\r (no-eol) (esc)
   archiving (sub1/sub2) [===================>           ] 2/3\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub3) [                                    ] 0/1\r (no-eol) (esc)
   archiving (sub3) [===================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   diff -Nru cloned.*/.hglf/b.dat cloned.*/.hglf/b.dat (glob)
   --- cloned.*/.hglf/b.dat	* (glob)
   +++ cloned.*/.hglf/b.dat	* (glob)
   @@ -*,0 +1* @@ (glob)
   +da39a3ee5e6b4b0d3255bfef95601890afd80709
   diff -Nru cloned.*/.hglf/foo/bar/large.dat cloned.*/.hglf/foo/bar/large.dat (glob)
   --- cloned.*/.hglf/foo/bar/large.dat	* (glob)
   +++ cloned.*/.hglf/foo/bar/large.dat	* (glob)
   @@ -*,0 +1* @@ (glob)
   +2f6933b5ee0f5fdd823d9717d8729f3c2523811b
   diff -Nru cloned.*/.hglf/large.bin cloned.*/.hglf/large.bin (glob)
   --- cloned.*/.hglf/large.bin	* (glob)
   +++ cloned.*/.hglf/large.bin	* (glob)
   @@ -*,0 +1* @@ (glob)
   +7f7097b041ccf68cc5561e9600da4655d21c6d18
   diff -Nru cloned.*/.hgsub cloned.*/.hgsub (glob)
   --- cloned.*/.hgsub	* (glob)
   +++ cloned.*/.hgsub	* (glob)
   @@ -1* +1,2 @@ (glob)
    sub1 = ../sub1
   +sub3 = sub3
   diff -Nru cloned.*/.hgsubstate cloned.*/.hgsubstate (glob)
   --- cloned.*/.hgsubstate	* (glob)
   +++ cloned.*/.hgsubstate	* (glob)
   @@ -1* +1,2 @@ (glob)
   -fc3b4ce2696f7741438c79207583768f2ce6b0dd sub1
   +7a36fa02b66e61f27f3d4a822809f159479b8ab2 sub1
   +b1a26de6f2a045a9f079323693614ee322f1ff7e sub3
   diff -Nru cloned.*/foo/bar/def cloned.*/foo/bar/def (glob)
   --- cloned.*/foo/bar/def	* (glob)
   +++ cloned.*/foo/bar/def	* (glob)
   @@ -*,0 +1* @@ (glob)
   +changed
   diff -Nru cloned.*/main cloned.*/main (glob)
   --- cloned.*/main	* (glob)
   +++ cloned.*/main	* (glob)
   @@ -1* +1* @@ (glob)
   -main
   +foo
   diff -Nru cloned.*/sub1/.hgsubstate cloned.*/sub1/.hgsubstate (glob)
   --- cloned.*/sub1/.hgsubstate	* (glob)
   +++ cloned.*/sub1/.hgsubstate	* (glob)
   @@ -1* +1* @@ (glob)
   -c57a0840e3badd667ef3c3ef65471609acb2ba3c sub2
   +c77908c81ccea3794a896c79e98b0e004aee2e9e sub2
   diff -Nru cloned.*/sub1/sub2/folder/test.txt cloned.*/sub1/sub2/folder/test.txt (glob)
   --- cloned.*/sub1/sub2/folder/test.txt	* (glob)
   +++ cloned.*/sub1/sub2/folder/test.txt	* (glob)
   @@ -*,0 +1* @@ (glob)
   +subfolder
   diff -Nru cloned.*/sub1/sub2/sub2 cloned.*/sub1/sub2/sub2 (glob)
   --- cloned.*/sub1/sub2/sub2	* (glob)
   +++ cloned.*/sub1/sub2/sub2	* (glob)
   @@ -1* +1* @@ (glob)
   -sub2
   +modified
   diff -Nru cloned.*/sub3/a.txt cloned.*/sub3/a.txt (glob)
   --- cloned.*/sub3/a.txt	* (glob)
   +++ cloned.*/sub3/a.txt	* (glob)
   @@ -*,0 +1* @@ (glob)
   +xyz
   [1]
 
   $ echo mod > sub1/sub2/sub2
   $ hg --config extensions.extdiff= pdiff -S
   \r (no-eol) (esc)
   archiving (sub1) [ <=>                                  ] 0\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (sub1/sub2) [                               ] 0/1\r (no-eol) (esc)
   archiving (sub1/sub2) [==============================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   --- */cloned.*/sub1/sub2/sub2	* (glob)
   +++ */cloned/sub1/sub2/sub2	* (glob)
   @@ -1* +1* @@ (glob)
   -modified
   +mod
   [1]
 
   $ cd ..

tests/test-subrepo-recursion.t

@@ -1,711 +1,708 b''
 Create test repository:
 
   $ hg init repo
   $ cd repo
   $ echo x1 > x.txt
 
   $ hg init foo
   $ cd foo
   $ echo y1 > y.txt
 
   $ hg init bar
   $ cd bar
   $ echo z1 > z.txt
 
   $ cd ..
   $ echo 'bar = bar' > .hgsub
 
   $ cd ..
   $ echo 'foo = foo' > .hgsub
 
 Add files --- .hgsub files must go first to trigger subrepos:
 
   $ hg add -S .hgsub
   $ hg add -S foo/.hgsub
   $ hg add -S foo/bar
   adding foo/bar/z.txt
   $ hg add -S
   adding x.txt
   adding foo/y.txt
 
 Test recursive status without committing anything:
 
   $ hg status -S
   A .hgsub
   A foo/.hgsub
   A foo/bar/z.txt
   A foo/y.txt
   A x.txt
 
 Test recursive diff without committing anything:
 
   $ hg diff --nodates -S foo
   diff -r 000000000000 foo/.hgsub
   --- /dev/null
   +++ b/foo/.hgsub
   @@ -0,0 +1,1 @@
   +bar = bar
   diff -r 000000000000 foo/y.txt
   --- /dev/null
   +++ b/foo/y.txt
   @@ -0,0 +1,1 @@
   +y1
   diff -r 000000000000 foo/bar/z.txt
   --- /dev/null
   +++ b/foo/bar/z.txt
   @@ -0,0 +1,1 @@
   +z1
 
 Commits:
 
   $ hg commit -m fails
   abort: uncommitted changes in subrepository "foo"
   (use --subrepos for recursive commit)
   [255]
 
 The --subrepos flag overwrite the config setting:
 
   $ hg commit -m 0-0-0 --config ui.commitsubrepos=No --subrepos
   committing subrepository foo
   committing subrepository foo/bar
 
   $ cd foo
   $ echo y2 >> y.txt
   $ hg commit -m 0-1-0
 
   $ cd bar
   $ echo z2 >> z.txt
   $ hg commit -m 0-1-1
 
   $ cd ..
   $ hg commit -m 0-2-1
 
   $ cd ..
   $ hg commit -m 1-2-1
 
 Change working directory:
 
   $ echo y3 >> foo/y.txt
   $ echo z3 >> foo/bar/z.txt
   $ hg status -S
   M foo/bar/z.txt
   M foo/y.txt
   $ hg diff --nodates -S
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
 
 Status call crossing repository boundaries:
 
   $ hg status -S foo/bar/z.txt
   M foo/bar/z.txt
   $ hg status -S -I 'foo/?.txt'
   M foo/y.txt
   $ hg status -S -I '**/?.txt'
   M foo/bar/z.txt
   M foo/y.txt
   $ hg diff --nodates -S -I '**/?.txt'
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
 
 Status from within a subdirectory:
 
   $ mkdir dir
   $ cd dir
   $ echo a1 > a.txt
   $ hg status -S
   M foo/bar/z.txt
   M foo/y.txt
   ? dir/a.txt
   $ hg diff --nodates -S
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
 
 Status with relative path:
 
   $ hg status -S ..
   M ../foo/bar/z.txt
   M ../foo/y.txt
   ? a.txt
 
 XXX: filtering lfilesrepo.status() in 3.3-rc causes these files to be listed as
 added instead of modified.
   $ hg status -S .. --config extensions.largefiles=
   M ../foo/bar/z.txt
   M ../foo/y.txt
   ? a.txt
 
   $ hg diff --nodates -S ..
   diff -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,2 +1,3 @@
    y1
    y2
   +y3
   diff -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,2 +1,3 @@
    z1
    z2
   +z3
   $ cd ..
 
 Cleanup and final commit:
 
   $ rm -r dir
   $ hg commit --subrepos -m 2-3-2
   committing subrepository foo
   committing subrepository foo/bar
 
 Test explicit path commands within subrepos: add/forget
   $ echo z1 > foo/bar/z2.txt
   $ hg status -S
   ? foo/bar/z2.txt
   $ hg add foo/bar/z2.txt
   $ hg status -S
   A foo/bar/z2.txt
   $ hg forget foo/bar/z2.txt
   $ hg status -S
   ? foo/bar/z2.txt
   $ hg forget foo/bar/z2.txt
   not removing foo/bar/z2.txt: file is already untracked
   [1]
   $ hg status -S
   ? foo/bar/z2.txt
   $ rm foo/bar/z2.txt
 
 Log with the relationships between repo and its subrepo:
 
   $ hg log --template '{rev}:{node|short} {desc}\n'
   2:1326fa26d0c0 2-3-2
   1:4b3c9ff4f66b 1-2-1
   0:23376cbba0d8 0-0-0
 
   $ hg -R foo log --template '{rev}:{node|short} {desc}\n'
   3:65903cebad86 2-3-2
   2:d254738c5f5e 0-2-1
   1:8629ce7dcc39 0-1-0
   0:af048e97ade2 0-0-0
 
   $ hg -R foo/bar log --template '{rev}:{node|short} {desc}\n'
   2:31ecbdafd357 2-3-2
   1:9647f22de499 0-1-1
   0:4904098473f9 0-0-0
 
 Status between revisions:
 
   $ hg status -S
   $ hg status -S --rev 0:1
   M .hgsubstate
   M foo/.hgsubstate
   M foo/bar/z.txt
   M foo/y.txt
   $ hg diff --nodates -S -I '**/?.txt' --rev 0:1
   diff -r af048e97ade2 -r d254738c5f5e foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,1 +1,2 @@
    y1
   +y2
   diff -r 4904098473f9 -r 9647f22de499 foo/bar/z.txt
   --- a/foo/bar/z.txt
   +++ b/foo/bar/z.txt
   @@ -1,1 +1,2 @@
    z1
   +z2
 
 #if serve
   $ cd ..
   $ hg serve -R repo --debug -S -p $HGPORT -d --pid-file=hg1.pid -E error.log -A access.log
   adding  = $TESTTMP/repo
   adding foo = $TESTTMP/repo/foo
   adding foo/bar = $TESTTMP/repo/foo/bar
   listening at http://*:$HGPORT/ (bound to *:$HGPORT) (glob) (?)
   adding  = $TESTTMP/repo (?)
   adding foo = $TESTTMP/repo/foo (?)
   adding foo/bar = $TESTTMP/repo/foo/bar (?)
   $ cat hg1.pid >> $DAEMON_PIDS
 
   $ hg clone http://localhost:$HGPORT clone  --config progress.disable=True
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 5 changes to 3 files
   new changesets 23376cbba0d8:1326fa26d0c0
   updating to branch default
   cloning subrepo foo from http://localhost:$HGPORT/foo
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 7 changes to 3 files
   new changesets af048e97ade2:65903cebad86
   cloning subrepo foo/bar from http://localhost:$HGPORT/foo/bar
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets 4904098473f9:31ecbdafd357
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cat clone/foo/bar/z.txt
   z1
   z2
   z3
 
 Clone pooling from a remote URL will share the top level repo and the subrepos,
 even if they are referenced by remote URL.
 
   $ hg --config extensions.share= --config share.pool=$TESTTMP/pool \
   >    clone http://localhost:$HGPORT shared
   (sharing from new pooled repository 23376cbba0d87c15906bb3652584927c140907bf)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 5 changes to 3 files
   new changesets 23376cbba0d8:1326fa26d0c0
   searching for changes
   no changes found
   updating working directory
   cloning subrepo foo from http://localhost:$HGPORT/foo
   (sharing from new pooled repository af048e97ade2e236f754f05d07013e586af0f8bf)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 7 changes to 3 files
   new changesets af048e97ade2:65903cebad86
   searching for changes
   no changes found
   cloning subrepo foo/bar from http://localhost:$HGPORT/foo/bar
   (sharing from new pooled repository 4904098473f96c900fec436dad267edd4da59fad)
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 1 files
   new changesets 4904098473f9:31ecbdafd357
   searching for changes
   no changes found
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ cat access.log
   * "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   * "GET /?cmd=batch HTTP/1.1" 200 - * (glob)
   * "GET /?cmd=getbundle HTTP/1.1" 200 - * (glob)
   * "GET /foo?cmd=capabilities HTTP/1.1" 200 - (glob)
   * "GET /foo?cmd=batch HTTP/1.1" 200 - * (glob)
   * "GET /foo?cmd=getbundle HTTP/1.1" 200 - * (glob)
   * "GET /foo/bar?cmd=capabilities HTTP/1.1" 200 - (glob)
   * "GET /foo/bar?cmd=batch HTTP/1.1" 200 - * (glob)
   * "GET /foo/bar?cmd=getbundle HTTP/1.1" 200 - * (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=0 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=1&common=0000000000000000000000000000000000000000&heads=1326fa26d0c00d2146c63b56bb6a45149d7325ac&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D1326fa26d0c00d2146c63b56bb6a45149d7325ac x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=0&common=1326fa26d0c00d2146c63b56bb6a45149d7325ac&heads=1326fa26d0c00d2146c63b56bb6a45149d7325ac&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=0 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=1&common=0000000000000000000000000000000000000000&heads=65903cebad86f1a84bd4f1134f62fa7dcb7a1c98&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D65903cebad86f1a84bd4f1134f62fa7dcb7a1c98 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=0&common=65903cebad86f1a84bd4f1134f62fa7dcb7a1c98&heads=65903cebad86f1a84bd4f1134f62fa7dcb7a1c98&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=lookup HTTP/1.1" 200 - x-hgarg-1:key=0 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=capabilities HTTP/1.1" 200 - (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=1&common=0000000000000000000000000000000000000000&heads=31ecbdafd357f54b281c9bd1d681bb90de219e22&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=batch HTTP/1.1" 200 - x-hgarg-1:cmds=heads+%3Bknown+nodes%3D31ecbdafd357f54b281c9bd1d681bb90de219e22 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
   $LOCALIP - - [$LOGDATE$] "GET /foo/bar?cmd=getbundle HTTP/1.1" 200 - x-hgarg-1:bookmarks=1&$USUAL_BUNDLE_CAPS$&cg=0&common=31ecbdafd357f54b281c9bd1d681bb90de219e22&heads=31ecbdafd357f54b281c9bd1d681bb90de219e22&listkeys=bookmarks&phases=1 x-hgproto-1:0.1 0.2 comp=$USUAL_COMPRESSIONS$ (glob)
 
   $ killdaemons.py
   $ rm hg1.pid error.log access.log
   $ cd repo
 #endif
 
 Enable progress extension for archive tests:
 
   $ cp $HGRCPATH $HGRCPATH.no-progress
   $ cat >> $HGRCPATH <<EOF
   > [progress]
   > disable=False
   > assume-tty = 1
   > delay = 0
   > # set changedelay really large so we don't see nested topics
   > changedelay = 30000
   > format = topic bar number
   > refresh = 0
   > width = 60
   > EOF
 
 Test archiving to a directory tree (the doubled lines in the output
 only show up in the test output, not in real usage):
 
   $ hg archive --subrepos ../archive
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   $ find ../archive | sort
   ../archive
   ../archive/.hg_archival.txt
   ../archive/.hgsub
   ../archive/.hgsubstate
   ../archive/foo
   ../archive/foo/.hgsub
   ../archive/foo/.hgsubstate
   ../archive/foo/bar
   ../archive/foo/bar/z.txt
   ../archive/foo/y.txt
   ../archive/x.txt
 
 Test archiving to zip file (unzip output is unstable):
 
   $ hg archive --subrepos --prefix '.' ../archive.zip
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
 
 (unzip date formating is unstable, we do not care about it and glob it out)
 
   $ unzip -l ../archive.zip | grep -v -- ----- | egrep -v files$
   Archive:  ../archive.zip
     Length [ ]* Date [ ]* Time [ ]* Name (re)
         172  [0-9:\- ]*  .hg_archival.txt (re)
          10  [0-9:\- ]*  .hgsub (re)
          45  [0-9:\- ]*  .hgsubstate (re)
           3  [0-9:\- ]*  x.txt (re)
          10  [0-9:\- ]*  foo/.hgsub (re)
          45  [0-9:\- ]*  foo/.hgsubstate (re)
           9  [0-9:\- ]*  foo/y.txt (re)
           9  [0-9:\- ]*  foo/bar/z.txt (re)
 
 Test archiving a revision that references a subrepo that is not yet
 cloned:
 
 #if hardlink
   $ hg clone -U . ../empty
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
   linking [       <=>                                     ] 7\r (no-eol) (esc)
   linking [        <=>                                    ] 8\r (no-eol) (esc)
   linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
   linking [          <=>                                 ] 10\r (no-eol) (esc) (reposimplestore !)
   linking [           <=>                                ] 11\r (no-eol) (esc) (reposimplestore !)
   linking [            <=>                               ] 12\r (no-eol) (esc) (reposimplestore !)
-  linking [             <=>                              ] 13\r (no-eol) (esc) (reposimplestore !)
                                                               \r (no-eol) (esc)
 #else
   $ hg clone -U . ../empty
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1 (no-eol)
 #endif
 
   $ cd ../empty
 #if hardlink
   $ hg archive --subrepos -r tip --prefix './' ../archive.tar.gz
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
   linking [       <=>                                     ] 7\r (no-eol) (esc)
   linking [        <=>                                    ] 8\r (no-eol) (esc)
   linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
   linking [          <=>                                 ] 10\r (no-eol) (esc) (reposimplestore !)
   linking [           <=>                                ] 11\r (no-eol) (esc) (reposimplestore !)
   linking [            <=>                               ] 12\r (no-eol) (esc) (reposimplestore !)
   linking [             <=>                              ] 13\r (no-eol) (esc) (reposimplestore !)
   linking [              <=>                             ] 14\r (no-eol) (esc) (reposimplestore !)
-  linking [               <=>                            ] 15\r (no-eol) (esc) (reposimplestore !)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo) [                                     ] 0/3\r (no-eol) (esc)
   archiving (foo) [===========>                         ] 1/3\r (no-eol) (esc)
   archiving (foo) [=======================>             ] 2/3\r (no-eol) (esc)
   archiving (foo) [====================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   linking [  <=>                                          ] 2\r (no-eol) (esc)
   linking [   <=>                                         ] 3\r (no-eol) (esc)
   linking [    <=>                                        ] 4\r (no-eol) (esc)
   linking [     <=>                                       ] 5\r (no-eol) (esc)
   linking [      <=>                                      ] 6\r (no-eol) (esc)
   linking [       <=>                                     ] 7\r (no-eol) (esc) (reposimplestore !)
   linking [        <=>                                    ] 8\r (no-eol) (esc) (reposimplestore !)
-  linking [         <=>                                   ] 9\r (no-eol) (esc) (reposimplestore !)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   archiving (foo/bar) [                                 ] 0/1\r (no-eol) (esc)
   archiving (foo/bar) [================================>] 1/1\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   cloning subrepo foo from $TESTTMP/repo/foo
   cloning subrepo foo/bar from $TESTTMP/repo/foo/bar
 #else
 Note there's a slight output glitch on non-hardlink systems: the last
 "linking" progress topic never gets closed, leading to slight output corruption on that platform.
   $ hg archive --subrepos -r tip --prefix './' ../archive.tar.gz
   \r (no-eol) (esc)
   archiving [                                           ] 0/3\r (no-eol) (esc)
   archiving [=============>                             ] 1/3\r (no-eol) (esc)
   archiving [===========================>               ] 2/3\r (no-eol) (esc)
   archiving [==========================================>] 3/3\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
   \r (no-eol) (esc)
   linking [ <=>                                           ] 1\r (no-eol) (esc)
   cloning subrepo foo/bar from $TESTTMP/repo/foo/bar
 #endif
 
 Archive + subrepos uses '/' for all component separators
 
   $ tar -tzf ../archive.tar.gz | sort
   .hg_archival.txt
   .hgsub
   .hgsubstate
   foo/.hgsub
   foo/.hgsubstate
   foo/bar/z.txt
   foo/y.txt
   x.txt
 
 The newly cloned subrepos contain no working copy:
 
   $ hg -R foo summary
   parent: -1:000000000000  (no revision checked out)
   branch: default
   commit: (clean)
   update: 4 new changesets (update)
 
 Sharing a local repo without the locally referenced subrepo (i.e. it was never
 updated from null), fails the same as a clone operation.
 
   $ hg --config progress.disable=True clone -U ../empty ../empty2
 
   $ hg --config extensions.share= --config progress.disable=True \
   >    share ../empty2 ../empty_share
   updating working directory
   abort: repository $TESTTMP/empty2/foo not found!
   [255]
 
   $ hg --config progress.disable=True clone ../empty2 ../empty_clone
   updating to branch default
   abort: repository $TESTTMP/empty2/foo not found!
   [255]
 
 Disable progress extension and cleanup:
 
   $ mv $HGRCPATH.no-progress $HGRCPATH
 
 Test archiving when there is a directory in the way for a subrepo
 created by archive:
 
   $ hg clone -U . ../almost-empty
   $ cd ../almost-empty
   $ mkdir foo
   $ echo f > foo/f
   $ hg archive --subrepos -r tip archive
   cloning subrepo foo from $TESTTMP/empty/foo
   abort: destination '$TESTTMP/almost-empty/foo' is not empty (in subrepository "foo")
   [255]
 
 Clone and test outgoing:
 
   $ cd ..
   $ hg clone repo repo2
   updating to branch default
   cloning subrepo foo from $TESTTMP/repo/foo
   cloning subrepo foo/bar from $TESTTMP/repo/foo/bar
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo2
   $ hg outgoing -S
   comparing with $TESTTMP/repo
   searching for changes
   no changes found
   comparing with $TESTTMP/repo/foo
   searching for changes
   no changes found
   comparing with $TESTTMP/repo/foo/bar
   searching for changes
   no changes found
   [1]
 
 Make nested change:
 
   $ echo y4 >> foo/y.txt
   $ hg diff --nodates -S
   diff -r 65903cebad86 foo/y.txt
   --- a/foo/y.txt
   +++ b/foo/y.txt
   @@ -1,3 +1,4 @@
    y1
    y2
    y3
   +y4
   $ hg commit --subrepos -m 3-4-2
   committing subrepository foo
   $ hg outgoing -S
   comparing with $TESTTMP/repo
   searching for changes
   changeset:   3:2655b8ecc4ee
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo/foo
   searching for changes
   changeset:   4:e96193d6cb36
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo/foo/bar
   searching for changes
   no changes found
 
 
 Switch to original repo and setup default path:
 
   $ cd ../repo
   $ echo '[paths]' >> .hg/hgrc
   $ echo 'default = ../repo2' >> .hg/hgrc
 
 Test incoming:
 
   $ hg incoming -S
   comparing with $TESTTMP/repo2
   searching for changes
   changeset:   3:2655b8ecc4ee
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo2/foo
   searching for changes
   changeset:   4:e96193d6cb36
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     3-4-2
   
   comparing with $TESTTMP/repo2/foo/bar
   searching for changes
   no changes found
 
   $ hg incoming -S --bundle incoming.hg
   abort: cannot combine --bundle and --subrepos
   [255]
 
 Test missing subrepo:
 
   $ rm -r foo
   $ hg status -S
   warning: error "unknown revision '65903cebad86f1a84bd4f1134f62fa7dcb7a1c98'" in subrepository "foo"
 
 Issue2619: IndexError: list index out of range on hg add with subrepos
 The subrepo must sorts after the explicit filename.
 
   $ cd ..
   $ hg init test
   $ cd test
   $ hg init x
   $ echo abc > abc.txt
   $ hg ci -Am "abc"
   adding abc.txt
   $ echo "x = x" >> .hgsub
   $ hg add .hgsub
   $ touch a x/a
   $ hg add a x/a
 
   $ hg ci -Sm "added x"
   committing subrepository x
   $ echo abc > x/a
   $ hg revert --rev '.^' "set:subrepo('glob:x*')"
   abort: subrepository 'x' does not exist in 25ac2c9b3180!
   [255]
 
   $ cd ..

tests/test-treemanifest.t

@@ -1,876 +1,878 b''
 #require killdaemons
 
   $ cat << EOF >> $HGRCPATH
   > [ui]
   > ssh=$PYTHON "$TESTDIR/dummyssh"
   > EOF
 
 Set up repo
 
   $ hg --config experimental.treemanifest=True init repo
   $ cd repo
 
 Requirements get set on init
 
   $ grep treemanifest .hg/requires
   treemanifest
 
 Without directories, looks like any other repo
 
   $ echo 0 > a
   $ echo 0 > b
   $ hg ci -Aqm initial
   $ hg debugdata -m 0
   a\x00362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (esc)
   b\x00362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (esc)
 
 Submanifest is stored in separate revlog
 
   $ mkdir dir1
   $ echo 1 > dir1/a
   $ echo 1 > dir1/b
   $ echo 1 > e
   $ hg ci -Aqm 'add dir1'
   $ hg debugdata -m 1
   a\x00362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (esc)
   b\x00362fef284ce2ca02aecc8de6d5e8a1c3af0556fe (esc)
   dir1\x008b3ffd73f901e83304c83d33132c8e774ceac44et (esc)
   e\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   $ hg debugdata --dir dir1 0
   a\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
   b\x00b8e02f6433738021a065f94175c7cd23db5f05be (esc)
 
 Can add nested directories
 
   $ mkdir dir1/dir1
   $ echo 2 > dir1/dir1/a
   $ echo 2 > dir1/dir1/b
   $ mkdir dir1/dir2
   $ echo 2 > dir1/dir2/a
   $ echo 2 > dir1/dir2/b
   $ hg ci -Aqm 'add dir1/dir1'
   $ hg files -r .
   a
   b
   dir1/a
   dir1/b
   dir1/dir1/a
   dir1/dir1/b
   dir1/dir2/a
   dir1/dir2/b
   e
 
 The manifest command works
 
   $ hg manifest
   a
   b
   dir1/a
   dir1/b
   dir1/dir1/a
   dir1/dir1/b
   dir1/dir2/a
   dir1/dir2/b
   e
 
 Revision is not created for unchanged directory
 
   $ mkdir dir2
   $ echo 3 > dir2/a
   $ hg add dir2
   adding dir2/a
   $ hg debugindex --dir dir1 > before
   $ hg ci -qm 'add dir2'
   $ hg debugindex --dir dir1 > after
   $ diff before after
   $ rm before after
 
 Removing directory does not create an revlog entry
 
   $ hg rm dir1/dir1
   removing dir1/dir1/a
   removing dir1/dir1/b
   $ hg debugindex --dir dir1/dir1 > before
   $ hg ci -qm 'remove dir1/dir1'
   $ hg debugindex --dir dir1/dir1 > after
   $ diff before after
   $ rm before after
 
 Check that hg files (calls treemanifest.walk()) works
 without loading all directory revlogs
 
   $ hg co 'desc("add dir2")'
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ mv .hg/store/meta/dir2 .hg/store/meta/dir2-backup
   $ hg files -r . dir1
   dir1/a
   dir1/b
   dir1/dir1/a
   dir1/dir1/b
   dir1/dir2/a
   dir1/dir2/b
 
 Check that status between revisions works (calls treemanifest.matches())
 without loading all directory revlogs
 
   $ hg status --rev 'desc("add dir1")' --rev . dir1
   A dir1/dir1/a
   A dir1/dir1/b
   A dir1/dir2/a
   A dir1/dir2/b
   $ mv .hg/store/meta/dir2-backup .hg/store/meta/dir2
 
 Merge creates 2-parent revision of directory revlog
 
   $ echo 5 > dir1/a
   $ hg ci -Aqm 'modify dir1/a'
   $ hg co '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 6 > dir1/b
   $ hg ci -Aqm 'modify dir1/b'
   $ hg merge 'desc("modify dir1/a")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'conflict-free merge involving dir1/'
   $ cat dir1/a
   5
   $ cat dir1/b
   6
   $ hg debugindex --dir dir1
      rev linkrev nodeid       p1           p2
        0       1 8b3ffd73f901 000000000000 000000000000
        1       2 68e9d057c5a8 8b3ffd73f901 000000000000
        2       4 4698198d2624 68e9d057c5a8 000000000000
        3       5 44844058ccce 68e9d057c5a8 000000000000
        4       6 bf3d9b744927 68e9d057c5a8 000000000000
        5       7 dde7c0af2a03 bf3d9b744927 44844058ccce
 
 Merge keeping directory from parent 1 does not create revlog entry. (Note that
 dir1's manifest does change, but only because dir1/a's filelog changes.)
 
   $ hg co 'desc("add dir2")'
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 8 > dir2/a
   $ hg ci -m 'modify dir2/a'
   created new head
 
   $ hg debugindex --dir dir2 > before
   $ hg merge 'desc("modify dir1/a")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg revert -r 'desc("modify dir2/a")' .
   reverting dir1/a
   $ hg ci -m 'merge, keeping parent 1'
   $ hg debugindex --dir dir2 > after
   $ diff before after
   $ rm before after
 
 Merge keeping directory from parent 2 does not create revlog entry. (Note that
 dir2's manifest does change, but only because dir2/a's filelog changes.)
 
   $ hg co 'desc("modify dir2/a")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg debugindex --dir dir1 > before
   $ hg merge 'desc("modify dir1/a")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg revert -r 'desc("modify dir1/a")' .
   reverting dir2/a
   $ hg ci -m 'merge, keeping parent 2'
   created new head
   $ hg debugindex --dir dir1 > after
   $ diff before after
   $ rm before after
 
 Create flat source repo for tests with mixed flat/tree manifests
 
   $ cd ..
   $ hg init repo-flat
   $ cd repo-flat
 
 Create a few commits with flat manifest
 
   $ echo 0 > a
   $ echo 0 > b
   $ echo 0 > e
   $ for d in dir1 dir1/dir1 dir1/dir2 dir2
   > do
   >   mkdir $d
   >   echo 0 > $d/a
   >   echo 0 > $d/b
   > done
   $ hg ci -Aqm initial
 
   $ echo 1 > a
   $ echo 1 > dir1/a
   $ echo 1 > dir1/dir1/a
   $ hg ci -Aqm 'modify on branch 1'
 
   $ hg co 0
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 2 > b
   $ echo 2 > dir1/b
   $ echo 2 > dir1/dir1/b
   $ hg ci -Aqm 'modify on branch 2'
 
   $ hg merge 1
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'merge of flat manifests to new flat manifest'
 
   $ hg serve -p $HGPORT -d --pid-file=hg.pid --errorlog=errors.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 Create clone with tree manifests enabled
 
   $ cd ..
   $ hg clone --config experimental.treemanifest=1 \
   >   http://localhost:$HGPORT repo-mixed -r 1
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 14 changes to 11 files
   new changesets 5b02a3e8db7e:581ef6037d8b
   updating to branch default
   11 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd repo-mixed
   $ test -d .hg/store/meta
   [1]
   $ grep treemanifest .hg/requires
   treemanifest
 
 Should be possible to push updates from flat to tree manifest repo
 
   $ hg -R ../repo-flat push ssh://user@dummy/repo-mixed
   pushing to ssh://user@dummy/repo-mixed
   searching for changes
   remote: adding changesets
   remote: adding manifests
   remote: adding file changes
   remote: added 2 changesets with 3 changes to 3 files
 
 Commit should store revlog per directory
 
   $ hg co 1
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 3 > a
   $ echo 3 > dir1/a
   $ echo 3 > dir1/dir1/a
   $ hg ci -m 'first tree'
   created new head
   $ find .hg/store/meta | sort
   .hg/store/meta
   .hg/store/meta/dir1
   .hg/store/meta/dir1/00manifest.i
   .hg/store/meta/dir1/dir1
   .hg/store/meta/dir1/dir1/00manifest.i
   .hg/store/meta/dir1/dir2
   .hg/store/meta/dir1/dir2/00manifest.i
   .hg/store/meta/dir2
   .hg/store/meta/dir2/00manifest.i
 
 Merge of two trees
 
   $ hg co 2
   6 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 1
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg ci -m 'merge of flat manifests to new tree manifest'
   created new head
   $ hg diff -r 3
 
 Parent of tree root manifest should be flat manifest, and two for merge
 
   $ hg debugindex -m
      rev linkrev nodeid       p1           p2
        0       0 40536115ed9e 000000000000 000000000000
        1       1 f3376063c255 40536115ed9e 000000000000
        2       2 5d9b9da231a2 40536115ed9e 000000000000
        3       3 d17d663cbd8a 5d9b9da231a2 f3376063c255
        4       4 51e32a8c60ee f3376063c255 000000000000
        5       5 cc5baa78b230 5d9b9da231a2 f3376063c255
 
 
 Status across flat/tree boundary should work
 
   $ hg status --rev '.^' --rev .
   M a
   M dir1/a
   M dir1/dir1/a
 
 
 Turning off treemanifest config has no effect
 
   $ hg debugindex --dir dir1
      rev linkrev nodeid       p1           p2
        0       4 064927a0648a 000000000000 000000000000
        1       5 25ecb8cb8618 000000000000 000000000000
   $ echo 2 > dir1/a
   $ hg --config experimental.treemanifest=False ci -qm 'modify dir1/a'
   $ hg debugindex --dir dir1
      rev linkrev nodeid       p1           p2
        0       4 064927a0648a 000000000000 000000000000
        1       5 25ecb8cb8618 000000000000 000000000000
        2       6 5b16163a30c6 25ecb8cb8618 000000000000
 
 Stripping and recovering changes should work
 
   $ hg st --change tip
   M dir1/a
   $ hg --config extensions.strip= strip tip
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   saved backup bundle to $TESTTMP/repo-mixed/.hg/strip-backup/51cfd7b1e13b-78a2f3ed-backup.hg
   $ hg debugindex --dir dir1
      rev linkrev nodeid       p1           p2
        0       4 064927a0648a 000000000000 000000000000
        1       5 25ecb8cb8618 000000000000 000000000000
 
 #if repobundlerepo
   $ hg incoming .hg/strip-backup/*
   comparing with .hg/strip-backup/*-backup.hg (glob)
   searching for changes
   changeset:   6:51cfd7b1e13b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     modify dir1/a
   
 #endif
 
   $ hg unbundle .hg/strip-backup/*
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files
   new changesets 51cfd7b1e13b
   (run 'hg update' to get a working copy)
   $ hg --config extensions.strip= strip tip
   saved backup bundle to $TESTTMP/repo-mixed/.hg/strip-backup/*-backup.hg (glob)
   $ hg unbundle -q .hg/strip-backup/*
   $ hg debugindex --dir dir1
      rev linkrev nodeid       p1           p2
        0       4 064927a0648a 000000000000 000000000000
        1       5 25ecb8cb8618 000000000000 000000000000
        2       6 5b16163a30c6 25ecb8cb8618 000000000000
   $ hg st --change tip
   M dir1/a
 
 Shelving and unshelving should work
 
   $ echo foo >> dir1/a
   $ hg --config extensions.shelve= shelve
   shelved as default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg --config extensions.shelve= unshelve
   unshelving change 'default'
   $ hg diff --nodates
   diff -r 708a273da119 dir1/a
   --- a/dir1/a
   +++ b/dir1/a
   @@ -1,1 +1,2 @@
    1
   +foo
 
 Pushing from treemanifest repo to an empty repo makes that a treemanifest repo
 
   $ cd ..
   $ hg init empty-repo
   $ cat << EOF >> empty-repo/.hg/hgrc
   > [experimental]
   > changegroup3=yes
   > EOF
   $ grep treemanifest empty-repo/.hg/requires
   [1]
   $ hg push -R repo -r 0 empty-repo
   pushing to empty-repo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 2 changes to 2 files
   $ grep treemanifest empty-repo/.hg/requires
   treemanifest
 
 Pushing to an empty repo works
 
   $ hg --config experimental.treemanifest=1 init clone
   $ grep treemanifest clone/.hg/requires
   treemanifest
   $ hg push -R repo clone
   pushing to clone
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 11 changesets with 15 changes to 10 files (+3 heads)
   $ grep treemanifest clone/.hg/requires
   treemanifest
   $ hg -R clone verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   10 files, 11 changesets, 15 total revisions
 
 Create deeper repo with tree manifests.
 
   $ hg --config experimental.treemanifest=True init deeprepo
   $ cd deeprepo
 
   $ mkdir .A
   $ mkdir b
   $ mkdir b/bar
   $ mkdir b/bar/orange
   $ mkdir b/bar/orange/fly
   $ mkdir b/foo
   $ mkdir b/foo/apple
   $ mkdir b/foo/apple/bees
 
   $ touch .A/one.txt
   $ touch .A/two.txt
   $ touch b/bar/fruits.txt
   $ touch b/bar/orange/fly/gnat.py
   $ touch b/bar/orange/fly/housefly.txt
   $ touch b/foo/apple/bees/flower.py
   $ touch c.txt
   $ touch d.py
 
   $ hg ci -Aqm 'initial'
 
   $ echo >> .A/one.txt
   $ echo >> .A/two.txt
   $ echo >> b/bar/fruits.txt
   $ echo >> b/bar/orange/fly/gnat.py
   $ echo >> b/bar/orange/fly/housefly.txt
   $ echo >> b/foo/apple/bees/flower.py
   $ echo >> c.txt
   $ echo >> d.py
   $ hg ci -Aqm 'second'
 
 We'll see that visitdir works by removing some treemanifest revlogs and running
 the files command with various parameters.
 
 Test files from the root.
 
   $ hg files -r .
   .A/one.txt
   .A/two.txt
   b/bar/fruits.txt
   b/bar/orange/fly/gnat.py
   b/bar/orange/fly/housefly.txt
   b/foo/apple/bees/flower.py
   c.txt
   d.py
 
 Excludes with a glob should not exclude everything from the glob's root
 
   $ hg files -r . -X 'b/fo?' b
   b/bar/fruits.txt
   b/bar/orange/fly/gnat.py
   b/bar/orange/fly/housefly.txt
   $ cp -R .hg/store .hg/store-copy
 
 Test files for a subdirectory.
 
   $ rm -r .hg/store/meta/~2e_a
   $ hg files -r . b
   b/bar/fruits.txt
   b/bar/orange/fly/gnat.py
   b/bar/orange/fly/housefly.txt
   b/foo/apple/bees/flower.py
   $ hg diff -r '.^' -r . --stat b
    b/bar/fruits.txt              |  1 +
    b/bar/orange/fly/gnat.py      |  1 +
    b/bar/orange/fly/housefly.txt |  1 +
    b/foo/apple/bees/flower.py    |  1 +
    4 files changed, 4 insertions(+), 0 deletions(-)
   $ cp -R .hg/store-copy/. .hg/store
 
 Test files with just includes and excludes.
 
   $ rm -r .hg/store/meta/~2e_a
   $ rm -r .hg/store/meta/b/bar/orange/fly
   $ rm -r .hg/store/meta/b/foo/apple/bees
   $ hg files -r . -I path:b/bar -X path:b/bar/orange/fly -I path:b/foo -X path:b/foo/apple/bees
   b/bar/fruits.txt
   $ hg diff -r '.^' -r . --stat -I path:b/bar -X path:b/bar/orange/fly -I path:b/foo -X path:b/foo/apple/bees
    b/bar/fruits.txt |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   $ cp -R .hg/store-copy/. .hg/store
 
 Test files for a subdirectory, excluding a directory within it.
 
   $ rm -r .hg/store/meta/~2e_a
   $ rm -r .hg/store/meta/b/foo
   $ hg files -r . -X path:b/foo b
   b/bar/fruits.txt
   b/bar/orange/fly/gnat.py
   b/bar/orange/fly/housefly.txt
   $ hg diff -r '.^' -r . --stat -X path:b/foo b
    b/bar/fruits.txt              |  1 +
    b/bar/orange/fly/gnat.py      |  1 +
    b/bar/orange/fly/housefly.txt |  1 +
    3 files changed, 3 insertions(+), 0 deletions(-)
   $ cp -R .hg/store-copy/. .hg/store
 
 Test files for a sub directory, including only a directory within it, and
 including an unrelated directory.
 
   $ rm -r .hg/store/meta/~2e_a
   $ rm -r .hg/store/meta/b/foo
   $ hg files -r . -I path:b/bar/orange -I path:a b
   b/bar/orange/fly/gnat.py
   b/bar/orange/fly/housefly.txt
   $ hg diff -r '.^' -r . --stat -I path:b/bar/orange -I path:a b
    b/bar/orange/fly/gnat.py      |  1 +
    b/bar/orange/fly/housefly.txt |  1 +
    2 files changed, 2 insertions(+), 0 deletions(-)
   $ cp -R .hg/store-copy/. .hg/store
 
 Test files for a pattern, including a directory, and excluding a directory
 within that.
 
   $ rm -r .hg/store/meta/~2e_a
   $ rm -r .hg/store/meta/b/foo
   $ rm -r .hg/store/meta/b/bar/orange
   $ hg files -r . glob:**.txt -I path:b/bar -X path:b/bar/orange
   b/bar/fruits.txt
   $ hg diff -r '.^' -r . --stat glob:**.txt -I path:b/bar -X path:b/bar/orange
    b/bar/fruits.txt |  1 +
    1 files changed, 1 insertions(+), 0 deletions(-)
   $ cp -R .hg/store-copy/. .hg/store
 
 Add some more changes to the deep repo
   $ echo narf >> b/bar/fruits.txt
   $ hg ci -m narf
   $ echo troz >> b/bar/orange/fly/gnat.py
   $ hg ci -m troz
 
 Verify works
   $ hg verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
+#if repofncache
 Dirlogs are included in fncache
   $ grep meta/.A/00manifest.i .hg/store/fncache
   meta/.A/00manifest.i
 
 Rebuilt fncache includes dirlogs
   $ rm .hg/store/fncache
   $ hg debugrebuildfncache
   adding data/.A/one.txt.i
   adding data/.A/two.txt.i
   adding data/b/bar/fruits.txt.i
   adding data/b/bar/orange/fly/gnat.py.i
   adding data/b/bar/orange/fly/housefly.txt.i
   adding data/b/foo/apple/bees/flower.py.i
   adding data/c.txt.i
   adding data/d.py.i
   adding meta/.A/00manifest.i
   adding meta/b/00manifest.i
   adding meta/b/bar/00manifest.i
   adding meta/b/bar/orange/00manifest.i
   adding meta/b/bar/orange/fly/00manifest.i
   adding meta/b/foo/00manifest.i
   adding meta/b/foo/apple/00manifest.i
   adding meta/b/foo/apple/bees/00manifest.i
   16 items added, 0 removed from fncache
+#endif
 
 Finish first server
   $ killdaemons.py
 
 Back up the recently added revlogs
   $ cp -R .hg/store .hg/store-newcopy
 
 Verify reports missing dirlog
   $ rm .hg/store/meta/b/00manifest.*
   $ hg verify
   checking changesets
   checking manifests
   checking directory manifests
    0: empty or missing b/
    b/@0: parent-directory manifest refers to unknown revision 67688a370455
    b/@1: parent-directory manifest refers to unknown revision f065da70369e
    b/@2: parent-directory manifest refers to unknown revision ac0d30948e0b
    b/@3: parent-directory manifest refers to unknown revision 367152e6af28
   warning: orphan data file 'meta/b/bar/00manifest.i'
   warning: orphan data file 'meta/b/bar/orange/00manifest.i'
   warning: orphan data file 'meta/b/bar/orange/fly/00manifest.i'
   warning: orphan data file 'meta/b/foo/00manifest.i'
   warning: orphan data file 'meta/b/foo/apple/00manifest.i'
   warning: orphan data file 'meta/b/foo/apple/bees/00manifest.i'
   crosschecking files in changesets and manifests
    b/bar/fruits.txt@0: in changeset but not in manifest
    b/bar/orange/fly/gnat.py@0: in changeset but not in manifest
    b/bar/orange/fly/housefly.txt@0: in changeset but not in manifest
    b/foo/apple/bees/flower.py@0: in changeset but not in manifest
   checking files
   8 files, 4 changesets, 18 total revisions
   6 warnings encountered!
   9 integrity errors encountered!
   (first damaged changeset appears to be 0)
   [1]
   $ cp -R .hg/store-newcopy/. .hg/store
 
 Verify reports missing dirlog entry
   $ mv -f .hg/store-copy/meta/b/00manifest.* .hg/store/meta/b/
   $ hg verify
   checking changesets
   checking manifests
   checking directory manifests
    b/@2: parent-directory manifest refers to unknown revision ac0d30948e0b
    b/@3: parent-directory manifest refers to unknown revision 367152e6af28
    b/bar/@?: rev 2 points to unexpected changeset 2
    b/bar/@?: 44d7e1146e0d not in parent-directory manifest
    b/bar/@?: rev 3 points to unexpected changeset 3
    b/bar/@?: 70b10c6b17b7 not in parent-directory manifest
    b/bar/orange/@?: rev 2 points to unexpected changeset 3
    (expected None)
    b/bar/orange/fly/@?: rev 2 points to unexpected changeset 3
    (expected None)
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
   2 warnings encountered!
   8 integrity errors encountered!
   (first damaged changeset appears to be 2)
   [1]
   $ cp -R .hg/store-newcopy/. .hg/store
 
 Test cloning a treemanifest repo over http.
   $ hg serve -p $HGPORT -d --pid-file=hg.pid --errorlog=errors.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ cd ..
 We can clone even with the knob turned off and we'll get a treemanifest repo.
   $ hg clone --config experimental.treemanifest=False \
   >   --config experimental.changegroup3=True \
   >   http://localhost:$HGPORT deepclone
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 18 changes to 8 files
   new changesets 775704be6f52:523e5c631710
   updating to branch default
   8 files updated, 0 files merged, 0 files removed, 0 files unresolved
 No server errors.
   $ cat deeprepo/errors.log
 requires got updated to include treemanifest
   $ cat deepclone/.hg/requires | grep treemanifest
   treemanifest
 Tree manifest revlogs exist.
   $ find deepclone/.hg/store/meta | sort
   deepclone/.hg/store/meta
   deepclone/.hg/store/meta/b
   deepclone/.hg/store/meta/b/00manifest.i
   deepclone/.hg/store/meta/b/bar
   deepclone/.hg/store/meta/b/bar/00manifest.i
   deepclone/.hg/store/meta/b/bar/orange
   deepclone/.hg/store/meta/b/bar/orange/00manifest.i
   deepclone/.hg/store/meta/b/bar/orange/fly
   deepclone/.hg/store/meta/b/bar/orange/fly/00manifest.i
   deepclone/.hg/store/meta/b/foo
   deepclone/.hg/store/meta/b/foo/00manifest.i
   deepclone/.hg/store/meta/b/foo/apple
   deepclone/.hg/store/meta/b/foo/apple/00manifest.i
   deepclone/.hg/store/meta/b/foo/apple/bees
   deepclone/.hg/store/meta/b/foo/apple/bees/00manifest.i
   deepclone/.hg/store/meta/~2e_a
   deepclone/.hg/store/meta/~2e_a/00manifest.i
 Verify passes.
   $ cd deepclone
   $ hg verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
   $ cd ..
 
 Create clones using old repo formats to use in later tests
   $ hg clone --config format.usestore=False \
   >   --config experimental.changegroup3=True \
   >   http://localhost:$HGPORT deeprepo-basicstore
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 18 changes to 8 files
   new changesets 775704be6f52:523e5c631710
   updating to branch default
   8 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd deeprepo-basicstore
   $ grep store .hg/requires
   [1]
   $ hg serve -p $HGPORT1 -d --pid-file=hg.pid --errorlog=errors.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ cd ..
   $ hg clone --config format.usefncache=False \
   >   --config experimental.changegroup3=True \
   >   http://localhost:$HGPORT deeprepo-encodedstore
   requesting all changes
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 18 changes to 8 files
   new changesets 775704be6f52:523e5c631710
   updating to branch default
   8 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd deeprepo-encodedstore
   $ grep fncache .hg/requires
   [1]
   $ hg serve -p $HGPORT2 -d --pid-file=hg.pid --errorlog=errors.log
   $ cat hg.pid >> $DAEMON_PIDS
   $ cd ..
 
 Local clone with basicstore
   $ hg clone -U deeprepo-basicstore local-clone-basicstore
   $ hg -R local-clone-basicstore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Local clone with encodedstore
   $ hg clone -U deeprepo-encodedstore local-clone-encodedstore
   $ hg -R local-clone-encodedstore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Local clone with fncachestore
   $ hg clone -U deeprepo local-clone-fncachestore
   $ hg -R local-clone-fncachestore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Stream clone with basicstore
   $ hg clone --config experimental.changegroup3=True --stream -U \
   >   http://localhost:$HGPORT1 stream-clone-basicstore
   streaming all changes
   18 files to transfer, * of data (glob)
   transferred * in * seconds (*) (glob)
   searching for changes
   no changes found
   $ hg -R stream-clone-basicstore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Stream clone with encodedstore
   $ hg clone --config experimental.changegroup3=True --stream -U \
   >   http://localhost:$HGPORT2 stream-clone-encodedstore
   streaming all changes
   18 files to transfer, * of data (glob)
   transferred * in * seconds (*) (glob)
   searching for changes
   no changes found
   $ hg -R stream-clone-encodedstore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Stream clone with fncachestore
   $ hg clone --config experimental.changegroup3=True --stream -U \
   >   http://localhost:$HGPORT stream-clone-fncachestore
   streaming all changes
   18 files to transfer, * of data (glob)
   transferred * in * seconds (*) (glob)
   searching for changes
   no changes found
   $ hg -R stream-clone-fncachestore verify
   checking changesets
   checking manifests
   checking directory manifests
   crosschecking files in changesets and manifests
   checking files
   8 files, 4 changesets, 18 total revisions
 
 Packed bundle
   $ hg -R deeprepo debugcreatestreamclonebundle repo-packed.hg
   writing 5330 bytes for 18 files
   bundle requirements: generaldelta, revlogv1, treemanifest
   $ hg debugbundle --spec repo-packed.hg
   none-packed1;requirements%3Dgeneraldelta%2Crevlogv1%2Ctreemanifest
 
 Bundle with changegroup2 is not supported
 
   $ hg -R deeprepo bundle --all -t v2 deeprepo.bundle
   abort: repository does not support bundle version 02
   [255]
 
 Pull does not include changegroup for manifest the client already has from
 other branch
 
   $ mkdir grafted-dir-repo
   $ cd grafted-dir-repo
   $ hg --config experimental.treemanifest=1 init
   $ mkdir dir
   $ echo a > dir/file
   $ echo a > file
   $ hg ci -Am initial
   adding dir/file
   adding file
   $ echo b > dir/file
   $ hg ci -m updated
   $ hg co '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg revert -r tip dir/
   reverting dir/file
   $ echo b > file # to make sure root manifest is sent
   $ hg ci -m grafted
   created new head
   $ cd ..
 
   $ hg --config experimental.treemanifest=1 clone --pull -r 1 \
   >   grafted-dir-repo grafted-dir-repo-clone
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 3 changes to 2 files
   new changesets d84f4c419457:09ab742f3b0f
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd grafted-dir-repo-clone
   $ hg pull -r 2
   pulling from $TESTTMP/grafted-dir-repo
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 1 changes to 1 files (+1 heads)
   new changesets 73699489fb7c
   (run 'hg heads' to see heads, 'hg merge' to merge)
 
 Committing a empty commit does not duplicate root treemanifest
   $ echo z >> z
   $ hg commit -Aqm 'pre-empty commit'
   $ hg rm z
   $ hg commit --amend -m 'empty commit'
   saved backup bundle to $TESTTMP/grafted-dir-repo-clone/.hg/strip-backup/cb99d5717cea-9e3b6b02-amend.hg
   $ hg log -r 'tip + tip^' -T '{manifest}\n'
   1:678d3574b88c
   1:678d3574b88c
   $ hg --config extensions.strip= strip -r . -q