hghave: add a check for the `xz` compression utility

This isn't install by default on Mac, which causes a test failure.  The logic
for avoiding the command is a little goofy, but nested `#if` isn't supported,
and it still seems worth running the hg command to see if anything explodes.

With this, the py3 tests run (almost) cleanly on 10.14.6:

    # Ran 835 tests, 58 skipped, 1 failed.

Alas, the mac-packaging test is skipped because it's slow.  The failure here is
in test-releasenotes-merging.t, complaining about not being able to import the
`fuzzywuzzy` module.  I have it installed on py3 (thus the test isn't skipped),
but not on py2.  So there must be some unintended cross pollination here when
running `hg` commands.

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

tests/hghave.py

@@ -1,1010 +1,1017 b''
 from __future__ import absolute_import, print_function
 
 import distutils.version
 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"),
 }
 
 try:
     import msvcrt
 
     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
     msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
 except ImportError:
     pass
 
 stdout = getattr(sys.stdout, 'buffer', sys.stdout)
 stderr = getattr(sys.stderr, 'buffer', sys.stderr)
 
 if sys.version_info[0] >= 3:
 
     def _bytespath(p):
         if p is None:
             return p
         return p.encode('utf-8')
 
     def _strpath(p):
         if p is None:
             return p
         return p.decode('utf-8')
 
 
 else:
 
     def _bytespath(p):
         return p
 
     _strpath = _bytespath
 
 
 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.
 
     Produces a series of feature checks that have the form <name><vers> without
     any punctuation (even if there's punctuation in 'vers'; i.e. this produces
     'py38', not 'py3.8' or 'py-38')."""
 
     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']:
         stderr.write(
             ('skipped: unknown feature: %s\n' % missing).encode('utf-8')
         )
     for msg in result['skipped']:
         stderr.write(('skipped: %s\n' % msg).encode('utf-8'))
     for msg in result['error']:
         stderr.write(('%s\n' % msg).encode('utf-8'))
 
     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)
     p = subprocess.Popen(
         cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT
     )
     s = p.communicate()[0]
     ret = p.returncode
     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('rc')[0].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():
     # mercurial.windows.checklink() is a hard 'no' at the moment
     if os.name == 'nt' or 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(_bytespath(fn), _bytespath(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():
     m = matchoutput('clang-format --version', br'clang-format version (\d)')
     # style changed somewhere between 4.x and 6.x
     return m and int(m.group(1)) >= 6
 
 
 @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 b'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("xz", "xz compression utility")
+def has_xz():
+    # When Windows invokes a subprocess in shell mode, it uses `cmd.exe`, which
+    # only knows `where`, not `which`.  So invoke MSYS shell explicitly.
+    return matchoutput("sh -c 'test -x \"`which xz`\"'", b'')
+
+
 @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/packaging/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'
 
 
 # Add "py27", "py35", ... as possible feature checks. Note that there's no
 # punctuation here.
 @checkvers("py", "Python >= %s", (2.7, 3.5, 3.6, 3.7, 3.8, 3.9))
 def has_python_range(v):
     major, minor = v.split('.')[0:2]
     py_major, py_minor = sys.version_info.major, sys.version_info.minor
 
     return (py_major, py_minor) >= (int(major), int(minor))
 
 
 @check("py3", "running with Python 3.x")
 def has_py3():
     return 3 == sys.version_info[0]
 
 
 @check("py3exe", "a Python 3.x interpreter is available")
 def has_python3exe():
     return matchoutput('python3 -V', br'^Python 3.(5|6|7|8|9)')
 
 
 @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("ensurepip", "ensurepip module")
 def has_ensurepip():
     try:
         import ensurepip
 
         ensurepip.bootstrap
         return True
     except ImportError:
         return False
 
 
 @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', br'clang version (\d)')
     if mat:
         # libfuzzer is new in clang 6
         return int(mat.group(1)) > 5
     return False
 
 
 @check("clang-6.0", "clang 6.0 with version suffix (libfuzzer included)")
 def has_clang60():
     return matchoutput('clang-6.0 --version', br'clang version 6\.')
 
 
 @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', '-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()
 
 
 @check('sqlite', 'sqlite3 module is available')
 def has_sqlite():
     try:
         import sqlite3
 
         version = sqlite3.sqlite_version_info
     except ImportError:
         return False
 
     if version < (3, 8, 3):
         # WITH clause not supported
         return False
 
     return matchoutput('sqlite3 -version', br'^3\.\d+')
 
 
 @check('vcr', 'vcr http mocking library')
 def has_vcr():
     try:
         import vcr
 
         vcr.VCR
         return True
     except (ImportError, AttributeError):
         pass
     return False
 
 
 @check('emacs', 'GNU Emacs')
 def has_emacs():
     # Our emacs lisp uses `with-eval-after-load` which is new in emacs
     # 24.4, so we allow emacs 24.4, 24.5, and 25+ (24.5 was the last
     # 24 release)
     return matchoutput('emacs --version', b'GNU Emacs 2(4.4|4.5|5|6|7|8|9)')
 
 
 @check('black', 'the black formatter for python')
 def has_black():
     blackcmd = 'black --version'
     version_regex = b'black, version ([0-9a-b.]+)'
     version = matchoutput(blackcmd, version_regex)
     sv = distutils.version.StrictVersion
     return version and sv(_strpath(version.group(1))) >= sv('19.10b0')
 
 
 @check('pytype', 'the pytype type checker')
 def has_pytype():
     pytypecmd = 'pytype --version'
     version = matchoutput(pytypecmd, b'[0-9a-b.]+')
     sv = distutils.version.StrictVersion
     return version and sv(_strpath(version.group(0))) >= sv('2019.10.17')

tests/test-archive.t

@@ -1,626 +1,626 b''
 #require serve
 
   $ hg init test
   $ cd test
   $ echo foo>foo
   $ hg commit -Am 1 -d '1 0'
   adding foo
   $ echo bar>bar
   $ hg commit -Am 2 -d '2 0'
   adding bar
   $ mkdir baz
   $ echo bletch>baz/bletch
   $ hg commit -Am 3 -d '1000000000 0'
   adding baz/bletch
   $ hg init subrepo
   $ touch subrepo/sub
   $ hg -q -R subrepo ci -Am "init subrepo"
   $ echo "subrepo = subrepo" > .hgsub
   $ hg add .hgsub
   $ hg ci -m "add subrepo"
 
   $ cat >> $HGRCPATH <<EOF
   > [extensions]
   > share =
   > EOF
 
 hg subrepos are shared when the parent repo is shared
 
   $ cd ..
   $ hg share test shared1
   updating working directory
   sharing subrepo subrepo from $TESTTMP/test/subrepo
   5 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat shared1/subrepo/.hg/sharedpath
   $TESTTMP/test/subrepo/.hg (no-eol)
 
 hg subrepos are shared into existence on demand if the parent was shared
 
   $ hg clone -qr 1 test clone1
   $ hg share clone1 share2
   updating working directory
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R clone1 -q pull
   $ hg -R share2 update tip
   sharing subrepo subrepo from $TESTTMP/test/subrepo
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat share2/subrepo/.hg/sharedpath
   $TESTTMP/test/subrepo/.hg (no-eol)
   $ echo 'mod' > share2/subrepo/sub
   $ hg -R share2 ci -Sqm 'subrepo mod'
   $ hg -R clone1 update -C tip
   cloning subrepo subrepo from $TESTTMP/test/subrepo
   3 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ find share2 | egrep 'sharedpath|00.+\.i' | sort
   share2/.hg/sharedpath
   share2/subrepo/.hg/sharedpath
   $ hg -R share2 unshare
   unsharing subrepo 'subrepo'
   $ find share2 | egrep 'sharedpath|00.+\.i' | sort
   share2/.hg/00changelog.i
   share2/.hg/sharedpath.old
   share2/.hg/store/00changelog.i
   share2/.hg/store/00manifest.i
   share2/subrepo/.hg/00changelog.i
   share2/subrepo/.hg/sharedpath.old
   share2/subrepo/.hg/store/00changelog.i
   share2/subrepo/.hg/store/00manifest.i
   $ hg -R share2/subrepo log -r tip -T compact
   1[tip]   559dcc9bfa65   1970-01-01 00:00 +0000   test
     subrepo mod
   
   $ rm -rf clone1
 
   $ hg clone -qr 1 test clone1
   $ hg share clone1 shared3
   updating working directory
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg -R clone1 -q pull
   $ hg -R shared3 archive --config ui.archivemeta=False -r tip -S archive
   sharing subrepo subrepo from $TESTTMP/test/subrepo
   $ cat shared3/subrepo/.hg/sharedpath
   $TESTTMP/test/subrepo/.hg (no-eol)
   $ diff -r archive test
   Only in test: .hg
   Common subdirectories: archive/baz and test/baz (?)
   Common subdirectories: archive/subrepo and test/subrepo (?)
   Only in test/subrepo: .hg
   [1]
   $ rm -rf archive
 
   $ cd test
   $ echo "[web]" >> .hg/hgrc
   $ echo "name = test-archive" >> .hg/hgrc
   $ echo "archivesubrepos = True" >> .hg/hgrc
   $ cp .hg/hgrc .hg/hgrc-base
   > test_archtype() {
   >     echo "allow-archive = $1" >> .hg/hgrc
   >     test_archtype_run "$@"
   > }
   > test_archtype_deprecated() {
   >     echo "allow$1 = True" >> .hg/hgrc
   >     test_archtype_run "$@"
   > }
   > test_archtype_run() {
   >     hg serve -p $HGPORT -d --pid-file=hg.pid -E errors.log \
   >         --config extensions.blackbox= --config blackbox.track=develwarn
   >     cat hg.pid >> $DAEMON_PIDS
   >     echo % $1 allowed should give 200
   >     get-with-headers.py --bodyfile body localhost:$HGPORT "archive/tip.$2" -
   >     f --size --sha1 body
   >     echo % $3 and $4 disallowed should both give 403
   >     get-with-headers.py --bodyfile body localhost:$HGPORT "archive/tip.$3" -
   >     f --size --sha1 body
   >     get-with-headers.py --bodyfile body localhost:$HGPORT "archive/tip.$4" -
   >     f --size --sha1 body
   >     killdaemons.py
   >     cat errors.log
   >     hg blackbox --config extensions.blackbox= --config blackbox.track=
   >     cp .hg/hgrc-base .hg/hgrc
   > }
 
 check http return codes
 
   $ test_archtype gz tar.gz tar.bz2 zip
   % gz allowed should give 200
   200 Script output follows
   content-disposition: attachment; filename=test-archive-1701ef1f1510.tar.gz
   content-type: application/x-gzip
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=408, sha1=8fa06531bddecc365a9f5edb0f88b65974bfe505 (no-py38 !)
   body: size=506, sha1=70926a04cb8887d0bcccf5380488100a10222def (py38 !)
   % tar.bz2 and zip disallowed should both give 403
   403 Archive type not allowed: bz2
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1451, sha1=4c5cf0f574446c44feb7f88f4e0e2a56bd92c352
   403 Archive type not allowed: zip
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1451, sha1=cbfa5574b337348bfd0564cc534474d002e7d6c7
   $ test_archtype bz2 tar.bz2 zip tar.gz
   % bz2 allowed should give 200
   200 Script output follows
   content-disposition: attachment; filename=test-archive-1701ef1f1510.tar.bz2
   content-type: application/x-bzip2
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=426, sha1=8d87f5aba6e14f1bfea6c232985982c278b2fb0b (no-py38 !)
   body: size=506, sha1=1bd1f8e8d3701704bd4385038bd9c09b81c77f4e (py38 !)
   % zip and tar.gz disallowed should both give 403
   403 Archive type not allowed: zip
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1451, sha1=cbfa5574b337348bfd0564cc534474d002e7d6c7
   403 Archive type not allowed: gz
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1450, sha1=71f0b12d59f85fdcfe8ff493e2dc66863f2f7734
   $ test_archtype zip zip tar.gz tar.bz2
   % zip allowed should give 200
   200 Script output follows
   content-disposition: attachment; filename=test-archive-1701ef1f1510.zip
   content-type: application/zip
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=(1377|1461|1489), sha1=(677b14d3d048778d5eb5552c14a67e6192068650|be6d3983aa13dfe930361b2569291cdedd02b537|1897e496871aa89ad685a92b936f5fa0d008b9e8) (re)
   % tar.gz and tar.bz2 disallowed should both give 403
   403 Archive type not allowed: gz
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1450, sha1=71f0b12d59f85fdcfe8ff493e2dc66863f2f7734
   403 Archive type not allowed: bz2
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1451, sha1=4c5cf0f574446c44feb7f88f4e0e2a56bd92c352
 
 check http return codes (with deprecated option)
 
   $ test_archtype_deprecated gz tar.gz tar.bz2 zip
   % gz allowed should give 200
   200 Script output follows
   content-disposition: attachment; filename=test-archive-1701ef1f1510.tar.gz
   content-type: application/x-gzip
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=408, sha1=8fa06531bddecc365a9f5edb0f88b65974bfe505 (no-py38 !)
   body: size=506, sha1=70926a04cb8887d0bcccf5380488100a10222def (py38 !)
   % tar.bz2 and zip disallowed should both give 403
   403 Archive type not allowed: bz2
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1451, sha1=4c5cf0f574446c44feb7f88f4e0e2a56bd92c352
   403 Archive type not allowed: zip
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1451, sha1=cbfa5574b337348bfd0564cc534474d002e7d6c7
   $ test_archtype_deprecated bz2 tar.bz2 zip tar.gz
   % bz2 allowed should give 200
   200 Script output follows
   content-disposition: attachment; filename=test-archive-1701ef1f1510.tar.bz2
   content-type: application/x-bzip2
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=426, sha1=8d87f5aba6e14f1bfea6c232985982c278b2fb0b (no-py38 !)
   body: size=506, sha1=1bd1f8e8d3701704bd4385038bd9c09b81c77f4e (py38 !)
   % zip and tar.gz disallowed should both give 403
   403 Archive type not allowed: zip
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1451, sha1=cbfa5574b337348bfd0564cc534474d002e7d6c7
   403 Archive type not allowed: gz
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1450, sha1=71f0b12d59f85fdcfe8ff493e2dc66863f2f7734
   $ test_archtype_deprecated zip zip tar.gz tar.bz2
   % zip allowed should give 200
   200 Script output follows
   content-disposition: attachment; filename=test-archive-1701ef1f1510.zip
   content-type: application/zip
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=(1377|1461|1489), sha1=(677b14d3d048778d5eb5552c14a67e6192068650|be6d3983aa13dfe930361b2569291cdedd02b537|1897e496871aa89ad685a92b936f5fa0d008b9e8) (re)
   % tar.gz and tar.bz2 disallowed should both give 403
   403 Archive type not allowed: gz
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1450, sha1=71f0b12d59f85fdcfe8ff493e2dc66863f2f7734
   403 Archive type not allowed: bz2
   content-type: text/html; charset=ascii
   date: $HTTP_DATE$
   etag: W/"*" (glob)
   server: testing stub value
   transfer-encoding: chunked
   
   body: size=1451, sha1=4c5cf0f574446c44feb7f88f4e0e2a56bd92c352
 
   $ echo "allow-archive = gz bz2 zip" >> .hg/hgrc
   $ hg serve -p $HGPORT -d --pid-file=hg.pid -E errors.log
   $ cat hg.pid >> $DAEMON_PIDS
 
 check archive links' order
 
   $ get-with-headers.py localhost:$HGPORT "?revcount=1" | grep '/archive/tip.'
   <a href="/archive/tip.zip">zip</a>
   <a href="/archive/tip.tar.gz">gz</a>
   <a href="/archive/tip.tar.bz2">bz2</a>
 
 invalid arch type should give 404
 
   $ get-with-headers.py localhost:$HGPORT "archive/tip.invalid" | head -n 1
   404 Unsupported archive type: None
 
   $ TIP=`hg id -v | cut -f1 -d' '`
   $ QTIP=`hg id -q`
   $ cat > getarchive.py <<EOF
   > from __future__ import absolute_import
   > import os
   > import sys
   > from mercurial import (
   >     util,
   > )
   > try:
   >     # Set stdout to binary mode for win32 platforms
   >     import msvcrt
   >     msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
   > except ImportError:
   >     pass
   > if len(sys.argv) <= 3:
   >     node, archive = sys.argv[1:]
   >     requeststr = 'cmd=archive;node=%s;type=%s' % (node, archive)
   > else:
   >     node, archive, file = sys.argv[1:]
   >     requeststr = 'cmd=archive;node=%s;type=%s;file=%s' % (node, archive, file)
   > try:
   >     stdout = sys.stdout.buffer
   > except AttributeError:
   >     stdout = sys.stdout
   > try:
   >     f = util.urlreq.urlopen('http://$LOCALIP:%s/?%s'
   >                     % (os.environ['HGPORT'], requeststr))
   >     stdout.write(f.read())
   > except util.urlerr.httperror as e:
   >     sys.stderr.write(str(e) + '\n')
   > EOF
   $ "$PYTHON" getarchive.py "$TIP" gz | gunzip | tar tf - 2>/dev/null
   test-archive-1701ef1f1510/.hg_archival.txt
   test-archive-1701ef1f1510/.hgsub
   test-archive-1701ef1f1510/.hgsubstate
   test-archive-1701ef1f1510/bar
   test-archive-1701ef1f1510/baz/bletch
   test-archive-1701ef1f1510/foo
   test-archive-1701ef1f1510/subrepo/sub
   $ "$PYTHON" getarchive.py "$TIP" bz2 | bunzip2 | tar tf - 2>/dev/null
   test-archive-1701ef1f1510/.hg_archival.txt
   test-archive-1701ef1f1510/.hgsub
   test-archive-1701ef1f1510/.hgsubstate
   test-archive-1701ef1f1510/bar
   test-archive-1701ef1f1510/baz/bletch
   test-archive-1701ef1f1510/foo
   test-archive-1701ef1f1510/subrepo/sub
   $ "$PYTHON" getarchive.py "$TIP" zip > archive.zip
   $ unzip -t archive.zip
   Archive:  archive.zip
       testing: test-archive-1701ef1f1510/.hg_archival.txt*OK (glob)
       testing: test-archive-1701ef1f1510/.hgsub*OK (glob)
       testing: test-archive-1701ef1f1510/.hgsubstate*OK (glob)
       testing: test-archive-1701ef1f1510/bar*OK (glob)
       testing: test-archive-1701ef1f1510/baz/bletch*OK (glob)
       testing: test-archive-1701ef1f1510/foo*OK (glob)
       testing: test-archive-1701ef1f1510/subrepo/sub*OK (glob)
   No errors detected in compressed data of archive.zip.
 
 test that we can download single directories and files
 
   $ "$PYTHON" getarchive.py "$TIP" gz baz | gunzip | tar tf - 2>/dev/null
   test-archive-1701ef1f1510/baz/bletch
   $ "$PYTHON" getarchive.py "$TIP" gz foo | gunzip | tar tf - 2>/dev/null
   test-archive-1701ef1f1510/foo
 
 test that we detect file patterns that match no files
 
   $ "$PYTHON" getarchive.py "$TIP" gz foobar
   HTTP Error 404: file(s) not found: foobar
 
 test that we reject unsafe patterns
 
   $ "$PYTHON" getarchive.py "$TIP" gz relre:baz
   HTTP Error 404: file(s) not found: relre:baz
 
   $ killdaemons.py
 
   $ hg archive -t tar test.tar
   $ tar tf test.tar
   test/.hg_archival.txt
   test/.hgsub
   test/.hgsubstate
   test/bar
   test/baz/bletch
   test/foo
 
   $ hg archive --debug -t tbz2 -X baz test.tar.bz2 --config progress.debug=true
   archiving: 0/4 files (0.00%)
   archiving: .hgsub 1/4 files (25.00%)
   archiving: .hgsubstate 2/4 files (50.00%)
   archiving: bar 3/4 files (75.00%)
   archiving: foo 4/4 files (100.00%)
   $ bunzip2 -dc test.tar.bz2 | tar tf - 2>/dev/null
   test/.hg_archival.txt
   test/.hgsub
   test/.hgsubstate
   test/bar
   test/foo
 
   $ hg archive -t tgz -p %b-%h test-%h.tar.gz
   $ gzip -dc test-$QTIP.tar.gz | tar tf - 2>/dev/null
   test-1701ef1f1510/.hg_archival.txt
   test-1701ef1f1510/.hgsub
   test-1701ef1f1510/.hgsubstate
   test-1701ef1f1510/bar
   test-1701ef1f1510/baz/bletch
   test-1701ef1f1510/foo
 
   $ hg archive autodetected_test.tar
   $ tar tf autodetected_test.tar
   autodetected_test/.hg_archival.txt
   autodetected_test/.hgsub
   autodetected_test/.hgsubstate
   autodetected_test/bar
   autodetected_test/baz/bletch
   autodetected_test/foo
 
 The '-t' should override autodetection
 
   $ hg archive -t tar autodetect_override_test.zip
   $ tar tf autodetect_override_test.zip
   autodetect_override_test.zip/.hg_archival.txt
   autodetect_override_test.zip/.hgsub
   autodetect_override_test.zip/.hgsubstate
   autodetect_override_test.zip/bar
   autodetect_override_test.zip/baz/bletch
   autodetect_override_test.zip/foo
 
   $ for ext in tar tar.gz tgz tar.bz2 tbz2 zip; do
   >     hg archive auto_test.$ext
   >     if [ -d auto_test.$ext ]; then
   >         echo "extension $ext was not autodetected."
   >     fi
   > done
 
   $ cat > md5comp.py <<EOF
   > from __future__ import absolute_import, print_function
   > import hashlib
   > import sys
   > f1, f2 = sys.argv[1:3]
   > h1 = hashlib.md5(open(f1, 'rb').read()).hexdigest()
   > h2 = hashlib.md5(open(f2, 'rb').read()).hexdigest()
   > print(h1 == h2 or "md5 differ: " + repr((h1, h2)))
   > EOF
 
 archive name is stored in the archive, so create similar archives and
 rename them afterwards.
 
   $ hg archive -t tgz tip.tar.gz
   $ mv tip.tar.gz tip1.tar.gz
   $ sleep 1
   $ hg archive -t tgz tip.tar.gz
   $ mv tip.tar.gz tip2.tar.gz
   $ "$PYTHON" md5comp.py tip1.tar.gz tip2.tar.gz
   True
 
   $ hg archive -t zip -p /illegal test.zip
   abort: archive prefix contains illegal components
   [255]
   $ hg archive -t zip -p very/../bad test.zip
 
   $ hg archive --config ui.archivemeta=false -t zip -r 2 test.zip
   $ unzip -t test.zip
   Archive:  test.zip
       testing: test/bar*OK (glob)
       testing: test/baz/bletch*OK (glob)
       testing: test/foo*OK (glob)
   No errors detected in compressed data of test.zip.
 
   $ hg archive -t tar - | tar tf - 2>/dev/null
   test-1701ef1f1510/.hg_archival.txt
   test-1701ef1f1510/.hgsub
   test-1701ef1f1510/.hgsubstate
   test-1701ef1f1510/bar
   test-1701ef1f1510/baz/bletch
   test-1701ef1f1510/foo
 
   $ hg archive -r 0 -t tar rev-%r.tar
   $ [ -f rev-0.tar ]
 
 test .hg_archival.txt
 
   $ hg archive ../test-tags
   $ cat ../test-tags/.hg_archival.txt
   repo: daa7f7c60e0a224faa4ff77ca41b2760562af264
   node: 1701ef1f151069b8747038e93b5186bb43a47504
   branch: default
   latesttag: null
   latesttagdistance: 4
   changessincelatesttag: 4
   $ hg tag -r 2 mytag
   $ hg tag -r 2 anothertag
   $ hg archive -r 2 ../test-lasttag
   $ cat ../test-lasttag/.hg_archival.txt
   repo: daa7f7c60e0a224faa4ff77ca41b2760562af264
   node: 2c0277f05ed49d1c8328fb9ba92fba7a5ebcb33e
   branch: default
   tag: anothertag
   tag: mytag
 
   $ hg archive -t bogus test.bogus
   abort: unknown archive type 'bogus'
   [255]
 
 enable progress extension:
 
   $ cp $HGRCPATH $HGRCPATH.no-progress
   $ cat >> $HGRCPATH <<EOF
   > [progress]
   > assume-tty = 1
   > format = topic bar number
   > delay = 0
   > refresh = 0
   > width = 60
   > EOF
 
   $ hg archive ../with-progress
   \r (no-eol) (esc)
   archiving [                                           ] 0/6\r (no-eol) (esc)
   archiving [======>                                    ] 1/6\r (no-eol) (esc)
   archiving [=============>                             ] 2/6\r (no-eol) (esc)
   archiving [====================>                      ] 3/6\r (no-eol) (esc)
   archiving [===========================>               ] 4/6\r (no-eol) (esc)
   archiving [==================================>        ] 5/6\r (no-eol) (esc)
   archiving [==========================================>] 6/6\r (no-eol) (esc)
                                                               \r (no-eol) (esc)
 
 cleanup after progress extension test:
 
   $ cp $HGRCPATH.no-progress $HGRCPATH
 
 server errors
 
   $ cat errors.log
 
 empty repo
 
   $ hg init ../empty
   $ cd ../empty
   $ hg archive ../test-empty
   abort: no working directory: please specify a revision
   [255]
 
 old file -- date clamped to 1980
 
   $ touch -t 197501010000 old
   $ hg add old
   $ hg commit -m old
   $ hg archive ../old.zip
   $ unzip -l ../old.zip | grep -v -- ----- | egrep -v files$
   Archive:  ../old.zip
   \s*Length.* (re)
   *172*80*00:00*old/.hg_archival.txt (glob)
   *0*80*00:00*old/old (glob)
 
 test xz support only available in Python 3.4
 
 #if py3
   $ hg archive ../archive.txz
-  $ xz -l ../archive.txz | head -n1
-  Strms  Blocks   Compressed Uncompressed  Ratio  Check   Filename
+  $ which xz >/dev/null && xz -l ../archive.txz | head -n1 || true
+  Strms  Blocks   Compressed Uncompressed  Ratio  Check   Filename (xz !)
   $ rm -f ../archive.txz
 #else
   $ hg archive ../archive.txz
   abort: xz compression is only available in Python 3
   [255]
 #endif
 
 show an error when a provided pattern matches no files
 
   $ hg archive -I file_that_does_not_exist.foo ../empty.zip
   abort: no files match the archive pattern
   [255]
 
   $ hg archive -X * ../empty.zip
   abort: no files match the archive pattern
   [255]
 
   $ cd ..
 
 issue3600: check whether "hg archive" can create archive files which
 are extracted with expected timestamp, even though TZ is not
 configured as GMT.
 
   $ mkdir issue3600
   $ cd issue3600
 
   $ hg init repo
   $ echo a > repo/a
   $ hg -R repo add repo/a
   $ hg -R repo commit -m '#0' -d '456789012 21600'
   $ cat > show_mtime.py <<EOF
   > from __future__ import absolute_import, print_function
   > import os
   > import sys
   > print(int(os.stat(sys.argv[1]).st_mtime))
   > EOF
 
   $ hg -R repo archive --prefix tar-extracted archive.tar
   $ (TZ=UTC-3; export TZ; tar xf archive.tar)
   $ "$PYTHON" show_mtime.py tar-extracted/a
   456789012
 
   $ hg -R repo archive --prefix zip-extracted archive.zip
   $ (TZ=UTC-3; export TZ; unzip -q archive.zip)
   $ "$PYTHON" show_mtime.py zip-extracted/a
   456789012
 
   $ cd ..