run-tests.py
2967 lines
| 108.7 KiB
| text/x-python
|
PythonLexer
/ tests / run-tests.py
|
r2110 | #!/usr/bin/env python | ||
# | ||||
# run-tests.py - Run a set of tests on Mercurial | ||||
# | ||||
# Copyright 2006 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r2110 | |||
|
r8674 | # Modifying this script is tricky because it has many modes: | ||
# - serial (default) vs parallel (-jN, N > 1) | ||||
# - no coverage (default) vs coverage (-c, -C, -s) | ||||
# - temp install (default) vs specific hg script (--with-hg, --local) | ||||
# - tests are a mix of shell scripts and Python scripts | ||||
# | ||||
# If you change this script, it is recommended that you ensure you | ||||
# haven't broken it by running it in various modes with a representative | ||||
# sample of test scripts. For example: | ||||
|
r8843 | # | ||
|
r8674 | # 1) serial, no coverage, temp install: | ||
# ./run-tests.py test-s* | ||||
# 2) serial, no coverage, local hg: | ||||
# ./run-tests.py --local test-s* | ||||
# 3) serial, coverage, temp install: | ||||
# ./run-tests.py -c test-s* | ||||
# 4) serial, coverage, local hg: | ||||
# ./run-tests.py -c --local test-s* # unsupported | ||||
# 5) parallel, no coverage, temp install: | ||||
# ./run-tests.py -j2 test-s* | ||||
# 6) parallel, no coverage, local hg: | ||||
# ./run-tests.py -j2 --local test-s* | ||||
# 7) parallel, coverage, temp install: | ||||
# ./run-tests.py -j2 -c test-s* # currently broken | ||||
|
r9899 | # 8) parallel, coverage, local install: | ||
|
r8674 | # ./run-tests.py -j2 -c --local test-s* # unsupported (and broken) | ||
|
r9899 | # 9) parallel, custom tmp dir: | ||
# ./run-tests.py -j2 --tmpdir /tmp/myhgtests | ||||
|
r26158 | # 10) parallel, pure, tests that call run-tests: | ||
# ./run-tests.py --pure `grep -l run-tests.py *.t` | ||||
|
r8674 | # | ||
# (You could use any subset of the tests: test-s* happens to match | ||||
# enough that it's worth doing parallel runs, few enough that it | ||||
# completes fairly quickly, includes both shell and Python scripts, and | ||||
# includes some scripts that run daemon processes.) | ||||
|
r29485 | from __future__ import absolute_import, print_function | ||
|
r25031 | |||
|
r35188 | import argparse | ||
|
r2571 | import difflib | ||
|
r29485 | import distutils.version as version | ||
|
r2571 | import errno | ||
|
r28126 | import json | ||
|
r2571 | import os | ||
|
r29485 | import random | ||
import re | ||||
|
r10905 | import shutil | ||
|
r2571 | import signal | ||
|
r24967 | import socket | ||
|
r29485 | import subprocess | ||
|
r2571 | import sys | ||
|
r32302 | import sysconfig | ||
|
r2110 | import tempfile | ||
|
r29485 | import threading | ||
|
r2571 | import time | ||
|
r29485 | import unittest | ||
import xml.dom.minidom as minidom | ||||
|
r25031 | try: | ||
import Queue as queue | ||||
except ImportError: | ||||
import queue | ||||
|
r2110 | |||
|
r33121 | try: | ||
import shlex | ||||
shellquote = shlex.quote | ||||
except (ImportError, AttributeError): | ||||
import pipes | ||||
shellquote = pipes.quote | ||||
|
r29282 | if os.environ.get('RTUNICODEPEDANTRY', False): | ||
try: | ||||
reload(sys) | ||||
sys.setdefaultencoding("undefined") | ||||
except NameError: | ||||
pass | ||||
|
r33198 | origenviron = os.environ.copy() | ||
|
r25037 | osenvironb = getattr(os, 'environb', os.environ) | ||
|
r14019 | processlock = threading.Lock() | ||
|
r19413 | |||
|
r33552 | pygmentspresent = False | ||
|
r33500 | # ANSI color is unsupported prior to Windows 10 | ||
if os.name != 'nt': | ||||
try: # is pygments installed | ||||
import pygments | ||||
import pygments.lexers as lexers | ||||
|
r33813 | import pygments.lexer as lexer | ||
|
r33500 | import pygments.formatters as formatters | ||
|
r33813 | import pygments.token as token | ||
import pygments.style as style | ||||
|
r33552 | pygmentspresent = True | ||
|
r33581 | difflexer = lexers.DiffLexer() | ||
terminal256formatter = formatters.Terminal256Formatter() | ||||
|
r33500 | except ImportError: | ||
pass | ||||
|
r33420 | |||
|
r33813 | if pygmentspresent: | ||
class TestRunnerStyle(style.Style): | ||||
default_style = "" | ||||
skipped = token.string_to_tokentype("Token.Generic.Skipped") | ||||
failed = token.string_to_tokentype("Token.Generic.Failed") | ||||
skippedname = token.string_to_tokentype("Token.Generic.SName") | ||||
failedname = token.string_to_tokentype("Token.Generic.FName") | ||||
styles = { | ||||
skipped: '#e5e5e5', | ||||
skippedname: '#00ffff', | ||||
failed: '#7f0000', | ||||
failedname: '#ff0000', | ||||
} | ||||
class TestRunnerLexer(lexer.RegexLexer): | ||||
tokens = { | ||||
'root': [ | ||||
(r'^Skipped', token.Generic.Skipped, 'skipped'), | ||||
(r'^Failed ', token.Generic.Failed, 'failed'), | ||||
(r'^ERROR: ', token.Generic.Failed, 'failed'), | ||||
], | ||||
'skipped': [ | ||||
|
r33871 | (r'[\w-]+\.(t|py)', token.Generic.SName), | ||
|
r33813 | (r':.*', token.Generic.Skipped), | ||
], | ||||
'failed': [ | ||||
|
r33871 | (r'[\w-]+\.(t|py)', token.Generic.FName), | ||
|
r33813 | (r'(:| ).*', token.Generic.Failed), | ||
] | ||||
} | ||||
|
r33868 | runnerformatter = formatters.Terminal256Formatter(style=TestRunnerStyle) | ||
runnerlexer = TestRunnerLexer() | ||||
|
r25160 | if sys.version_info > (3, 5, 0): | ||
|
r25157 | PYTHON3 = True | ||
|
r25033 | xrange = range # we use xrange in one place, and we'd rather not use range | ||
|
r25161 | def _bytespath(p): | ||
|
r33676 | if p is None: | ||
return p | ||||
|
r25161 | return p.encode('utf-8') | ||
|
r25162 | |||
def _strpath(p): | ||||
|
r33676 | if p is None: | ||
return p | ||||
|
r25162 | return p.decode('utf-8') | ||
|
r25160 | elif sys.version_info >= (3, 0, 0): | ||
|
r32353 | print('%s is only supported on Python 3.5+ and 2.7, not %s' % | ||
|
r25160 | (sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3]))) | ||
sys.exit(70) # EX_SOFTWARE from `man 3 sysexit` | ||||
|
r25157 | else: | ||
PYTHON3 = False | ||||
|
r25162 | |||
# In python 2.x, path operations are generally done using | ||||
# bytestrings by default, so we don't have to do any extra | ||||
# fiddling there. We define the wrapper functions anyway just to | ||||
# help keep code consistent between platforms. | ||||
|
r25161 | def _bytespath(p): | ||
return p | ||||
|
r25033 | |||
|
r25162 | _strpath = _bytespath | ||
|
r25177 | # For Windows support | ||
wifexited = getattr(os, "WIFEXITED", lambda x: False) | ||||
|
r30984 | # Whether to use IPv6 | ||
|
r31002 | def checksocketfamily(name, port=20058): | ||
"""return true if we can listen on localhost using family=name | ||||
name should be either 'AF_INET', or 'AF_INET6'. | ||||
port being used is okay - EADDRINUSE is considered as successful. | ||||
""" | ||||
family = getattr(socket, name, None) | ||||
|
r30984 | if family is None: | ||
return False | ||||
try: | ||||
s = socket.socket(family, socket.SOCK_STREAM) | ||||
s.bind(('localhost', port)) | ||||
s.close() | ||||
return True | ||||
except socket.error as exc: | ||||
if exc.errno == errno.EADDRINUSE: | ||||
return True | ||||
elif exc.errno in (errno.EADDRNOTAVAIL, errno.EPROTONOSUPPORT): | ||||
return False | ||||
else: | ||||
raise | ||||
else: | ||||
return False | ||||
|
r31011 | # useipv6 will be set by parseargs | ||
useipv6 = None | ||||
|
r30984 | |||
|
r24967 | def checkportisavailable(port): | ||
"""return true if a port seems free to bind on localhost""" | ||||
|
r30985 | if useipv6: | ||
family = socket.AF_INET6 | ||||
else: | ||||
family = socket.AF_INET | ||||
|
r30987 | try: | ||
s = socket.socket(family, socket.SOCK_STREAM) | ||||
s.bind(('localhost', port)) | ||||
s.close() | ||||
return True | ||||
except socket.error as exc: | ||||
if exc.errno not in (errno.EADDRINUSE, errno.EADDRNOTAVAIL, | ||||
errno.EPROTONOSUPPORT): | ||||
raise | ||||
|
r30886 | return False | ||
|
r24967 | |||
|
r8280 | closefds = os.name == 'posix' | ||
|
r19262 | def Popen4(cmd, wd, timeout, env=None): | ||
|
r14019 | processlock.acquire() | ||
|
r19262 | p = subprocess.Popen(cmd, shell=True, bufsize=-1, cwd=wd, env=env, | ||
|
r8280 | close_fds=closefds, | ||
stdin=subprocess.PIPE, stdout=subprocess.PIPE, | ||||
stderr=subprocess.STDOUT) | ||||
|
r14019 | processlock.release() | ||
|
r8280 | p.fromchild = p.stdout | ||
p.tochild = p.stdin | ||||
p.childerr = p.stderr | ||||
|
r14001 | |||
|
r14337 | p.timeout = False | ||
|
r14001 | if timeout: | ||
def t(): | ||||
start = time.time() | ||||
while time.time() - start < timeout and p.returncode is None: | ||||
|
r16346 | time.sleep(.1) | ||
|
r14001 | p.timeout = True | ||
if p.returncode is None: | ||||
|
r14821 | terminate(p) | ||
|
r14001 | threading.Thread(target=t).start() | ||
|
r8280 | return p | ||
|
r25161 | PYTHON = _bytespath(sys.executable.replace('\\', '/')) | ||
|
r25041 | IMPL_PATH = b'PYTHONPATH' | ||
|
r10758 | if 'java' in sys.platform: | ||
|
r25041 | IMPL_PATH = b'JYTHONPATH' | ||
|
r4881 | |||
|
r6366 | defaults = { | ||
'jobs': ('HGTEST_JOBS', 1), | ||||
'timeout': ('HGTEST_TIMEOUT', 180), | ||||
|
r27141 | 'slowtimeout': ('HGTEST_SLOWTIMEOUT', 500), | ||
|
r6366 | 'port': ('HGTEST_PORT', 20059), | ||
|
r15941 | 'shell': ('HGTEST_SHELL', 'sh'), | ||
|
r6366 | } | ||
|
r28644 | def canonpath(path): | ||
return os.path.realpath(os.path.expanduser(path)) | ||||
|
r14493 | def parselistfiles(files, listtype, warn=True): | ||
entries = dict() | ||||
for filename in files: | ||||
try: | ||||
path = os.path.expanduser(os.path.expandvars(filename)) | ||||
|
r21916 | f = open(path, "rb") | ||
|
r25031 | except IOError as err: | ||
|
r14493 | if err.errno != errno.ENOENT: | ||
raise | ||||
if warn: | ||||
|
r25031 | print("warning: no such %s file: %s" % (listtype, filename)) | ||
|
r14493 | continue | ||
for line in f.readlines(): | ||||
|
r25041 | line = line.split(b'#', 1)[0].strip() | ||
|
r14493 | if line: | ||
entries[line] = filename | ||||
f.close() | ||||
return entries | ||||
|
r32317 | def parsettestcases(path): | ||
"""read a .t test file, return a set of test case names | ||||
If path does not exist, return an empty set. | ||||
""" | ||||
cases = set() | ||||
try: | ||||
with open(path, 'rb') as f: | ||||
for l in f: | ||||
if l.startswith(b'#testcases '): | ||||
cases.update(l[11:].split()) | ||||
except IOError as ex: | ||||
if ex.errno != errno.ENOENT: | ||||
raise | ||||
return cases | ||||
|
r21008 | def getparser(): | ||
|
r21383 | """Obtain the OptionParser used by the CLI.""" | ||
|
r35188 | parser = argparse.ArgumentParser(usage='%(prog)s [options] [tests]') | ||
|
r11039 | |||
|
r35189 | selection = parser.add_argument_group('Test Selection') | ||
selection.add_argument('--allow-slow-tests', action='store_true', | ||||
help='allow extremely slow tests') | ||||
selection.add_argument("--blacklist", action="append", | ||||
|
r11039 | help="skip tests listed in the specified blacklist file") | ||
|
r35189 | selection.add_argument("--changed", | ||
|
r20821 | help="run tests that are changed in parent rev or working directory") | ||
|
r35189 | selection.add_argument("-k", "--keywords", | ||
help="run tests matching keywords") | ||||
selection.add_argument("-r", "--retest", action="store_true", | ||||
help = "retest failed tests") | ||||
selection.add_argument("--test-list", action="append", | ||||
help="read tests to run from the specified file") | ||||
selection.add_argument("--whitelist", action="append", | ||||
help="always run tests listed in the specified whitelist file") | ||||
selection.add_argument('tests', metavar='TESTS', nargs='*', | ||||
help='Tests to run') | ||||
harness = parser.add_argument_group('Test Harness Behavior') | ||||
harness.add_argument('--bisect-repo', | ||||
metavar='bisect_repo', | ||||
help=("Path of a repo to bisect. Use together with " | ||||
"--known-good-rev")) | ||||
harness.add_argument("-d", "--debug", action="store_true", | ||||
|
r11039 | help="debug mode: write output of test scripts to console" | ||
|
r21024 | " rather than capturing and diffing it (disables timeout)") | ||
|
r35189 | harness.add_argument("-f", "--first", action="store_true", | ||
|
r8091 | help="exit on the first test failure") | ||
|
r35189 | harness.add_argument("-i", "--interactive", action="store_true", | ||
|
r8091 | help="prompt to accept changed output") | ||
|
r35189 | harness.add_argument("-j", "--jobs", type=int, | ||
|
r8091 | help="number of jobs to run in parallel" | ||
" (default: $%s or %d)" % defaults['jobs']) | ||||
|
r35189 | harness.add_argument("--keep-tmpdir", action="store_true", | ||
|
r9706 | help="keep temporary directory after running tests") | ||
|
r35189 | harness.add_argument('--known-good-rev', | ||
metavar="known_good_rev", | ||||
help=("Automatically bisect any failures using this " | ||||
"revision as a known-good revision.")) | ||||
harness.add_argument("--list-tests", action="store_true", | ||||
|
r32704 | help="list tests instead of running them") | ||
|
r35189 | harness.add_argument("--loop", action="store_true", | ||
help="loop tests repeatedly") | ||||
harness.add_argument('--random', action="store_true", | ||||
help='run tests in random order') | ||||
harness.add_argument("-p", "--port", type=int, | ||||
help="port on which servers should listen" | ||||
" (default: $%s or %d)" % defaults['port']) | ||||
harness.add_argument('--profile-runner', action='store_true', | ||||
help='run statprof on run-tests') | ||||
harness.add_argument("-R", "--restart", action="store_true", | ||||
help="restart at last error") | ||||
harness.add_argument("--runs-per-test", type=int, dest="runs_per_test", | ||||
help="run each test N times (default=1)", default=1) | ||||
harness.add_argument("--shell", | ||||
help="shell to use (default: $%s or %s)" % defaults['shell']) | ||||
harness.add_argument('--showchannels', action='store_true', | ||||
help='show scheduling channels') | ||||
harness.add_argument("--slowtimeout", type=int, | ||||
help="kill errant slow tests after SLOWTIMEOUT seconds" | ||||
" (default: $%s or %d)" % defaults['slowtimeout']) | ||||
harness.add_argument("-t", "--timeout", type=int, | ||||
help="kill errant tests after TIMEOUT seconds" | ||||
" (default: $%s or %d)" % defaults['timeout']) | ||||
harness.add_argument("--tmpdir", | ||||
help="run tests in the given temporary directory" | ||||
" (implies --keep-tmpdir)") | ||||
harness.add_argument("-v", "--verbose", action="store_true", | ||||
help="output verbose messages") | ||||
hgconf = parser.add_argument_group('Mercurial Configuration') | ||||
hgconf.add_argument("--chg", action="store_true", | ||||
help="install and use chg wrapper in place of hg") | ||||
hgconf.add_argument("--compiler", | ||||
help="compiler to build with") | ||||
hgconf.add_argument('--extra-config-opt', action="append", | ||||
help='set the given config opt in the test hgrc') | ||||
hgconf.add_argument("-l", "--local", action="store_true", | ||||
|
r29583 | help="shortcut for --with-hg=<testdir>/../hg, " | ||
"and --with-chg=<testdir>/../contrib/chg/chg if --chg is set") | ||||
|
r35189 | hgconf.add_argument("--ipv6", action="store_true", | ||
help="prefer IPv6 to IPv4 for network related tests") | ||||
hgconf.add_argument("--pure", action="store_true", | ||||
|
r11039 | help="use pure Python code instead of C extensions") | ||
|
r35189 | hgconf.add_argument("-3", "--py3k-warnings", action="store_true", | ||
help="enable Py3k warnings on Python 2.7+") | ||||
hgconf.add_argument("--with-chg", metavar="CHG", | ||||
help="use specified chg wrapper in place of hg") | ||||
hgconf.add_argument("--with-hg", | ||||
|
r8674 | metavar="HG", | ||
help="test using specified hg script rather than a " | ||||
"temporary installation") | ||||
|
r28582 | # This option should be deleted once test-check-py3-compat.t and other | ||
# Python 3 tests run with Python 3. | ||||
|
r35189 | hgconf.add_argument("--with-python3", metavar="PYTHON3", | ||
help="Python 3 interpreter (if running under Python 2)" | ||||
" (TEMPORARY)") | ||||
reporting = parser.add_argument_group('Results Reporting') | ||||
reporting.add_argument("-C", "--annotate", action="store_true", | ||||
help="output files annotated with coverage") | ||||
reporting.add_argument("--color", choices=["always", "auto", "never"], | ||||
default=os.environ.get('HGRUNTESTSCOLOR', 'auto'), | ||||
help="colorisation: always|auto|never (default: auto)") | ||||
reporting.add_argument("-c", "--cover", action="store_true", | ||||
help="print a test coverage report") | ||||
reporting.add_argument("-H", "--htmlcov", action="store_true", | ||||
help="create an HTML report of the coverage of the files") | ||||
reporting.add_argument("--json", action="store_true", | ||||
help="store test result data in 'report.json' file") | ||||
reporting.add_argument("--outputdir", | ||||
help="directory to write error logs to (default=test directory)") | ||||
reporting.add_argument("-n", "--nodiff", action="store_true", | ||||
help="skip showing test changes") | ||||
reporting.add_argument("-S", "--noskips", action="store_true", | ||||
help="don't report skip tests verbosely") | ||||
reporting.add_argument("--time", action="store_true", | ||||
help="time how long each test takes") | ||||
reporting.add_argument("--view", | ||||
help="external diff viewer") | ||||
reporting.add_argument("--xunit", | ||||
help="record xunit results at specified path") | ||||
|
r2110 | |||
|
r14201 | for option, (envvar, default) in defaults.items(): | ||
defaults[option] = type(default)(os.environ.get(envvar, default)) | ||||
|
r8091 | parser.set_defaults(**defaults) | ||
|
r21008 | |||
return parser | ||||
def parseargs(args, parser): | ||||
|
r21383 | """Parse arguments with our OptionParser and validate results.""" | ||
|
r35188 | options = parser.parse_args(args) | ||
|
r8091 | |||
|
r10758 | # jython is always pure | ||
|
r10766 | if 'java' in sys.platform or '__pypy__' in sys.modules: | ||
|
r10765 | options.pure = True | ||
|
r10758 | |||
|
r8674 | if options.with_hg: | ||
|
r28644 | options.with_hg = canonpath(_bytespath(options.with_hg)) | ||
|
r8674 | if not (os.path.isfile(options.with_hg) and | ||
os.access(options.with_hg, os.X_OK)): | ||||
parser.error('--with-hg must specify an executable hg script') | ||||
|
r32328 | if os.path.basename(options.with_hg) not in [b'hg', b'hg.exe']: | ||
|
r14359 | sys.stderr.write('warning: --with-hg should specify an hg script\n') | ||
|
r8674 | if options.local: | ||
|
r28644 | testdir = os.path.dirname(_bytespath(canonpath(sys.argv[0]))) | ||
|
r29582 | reporootdir = os.path.dirname(testdir) | ||
pathandattrs = [(b'hg', 'with_hg')] | ||||
|
r29583 | if options.chg: | ||
pathandattrs.append((b'contrib/chg/chg', 'with_chg')) | ||||
|
r29582 | for relpath, attr in pathandattrs: | ||
binpath = os.path.join(reporootdir, relpath) | ||||
if os.name != 'nt' and not os.access(binpath, os.X_OK): | ||||
parser.error('--local specified, but %r not found or ' | ||||
'not executable' % binpath) | ||||
setattr(options, attr, binpath) | ||||
|
r8674 | |||
|
r28143 | if (options.chg or options.with_chg) and os.name == 'nt': | ||
parser.error('chg does not work on %s' % os.name) | ||||
|
r28142 | if options.with_chg: | ||
|
r28143 | options.chg = False # no installation to temporary location | ||
|
r28644 | options.with_chg = canonpath(_bytespath(options.with_chg)) | ||
|
r28142 | if not (os.path.isfile(options.with_chg) and | ||
os.access(options.with_chg, os.X_OK)): | ||||
parser.error('--with-chg must specify a chg executable') | ||||
|
r28143 | if options.chg and options.with_hg: | ||
# chg shares installation location with hg | ||||
parser.error('--chg does not work when --with-hg is specified ' | ||||
'(use --with-chg instead)') | ||||
|
r28142 | |||
|
r33567 | if options.color == 'always' and not pygmentspresent: | ||
sys.stderr.write('warning: --color=always ignored because ' | ||||
'pygments is not installed\n') | ||||
|
r34043 | if options.bisect_repo and not options.known_good_rev: | ||
parser.error("--bisect-repo cannot be used without --known-good-rev") | ||||
|
r31011 | global useipv6 | ||
if options.ipv6: | ||||
useipv6 = checksocketfamily('AF_INET6') | ||||
else: | ||||
# only use IPv6 if IPv4 is unavailable and IPv6 is available | ||||
useipv6 = ((not checksocketfamily('AF_INET')) | ||||
and checksocketfamily('AF_INET6')) | ||||
|
r15859 | options.anycoverage = options.cover or options.annotate or options.htmlcov | ||
|
r10648 | if options.anycoverage: | ||
try: | ||||
import coverage | ||||
covver = version.StrictVersion(coverage.__version__).version | ||||
if covver < (3, 3): | ||||
parser.error('coverage options require coverage 3.3 or later') | ||||
except ImportError: | ||||
parser.error('coverage options now require the coverage package') | ||||
|
r8095 | |||
|
r10648 | if options.anycoverage and options.local: | ||
# this needs some path mangling somewhere, I guess | ||||
parser.error("sorry, coverage options do not work when --local " | ||||
"is specified") | ||||
|
r8674 | |||
|
r24506 | if options.anycoverage and options.with_hg: | ||
parser.error("sorry, coverage options do not work when --with-hg " | ||||
"is specified") | ||||
|
r19250 | global verbose | ||
|
r8095 | if options.verbose: | ||
|
r19279 | verbose = '' | ||
|
r8091 | |||
|
r9394 | if options.tmpdir: | ||
|
r28644 | options.tmpdir = canonpath(options.tmpdir) | ||
|
r9394 | |||
|
r8091 | if options.jobs < 1: | ||
|
r9408 | parser.error('--jobs must be positive') | ||
|
r9707 | if options.interactive and options.debug: | ||
parser.error("-i/--interactive and -d/--debug are incompatible") | ||||
if options.debug: | ||||
if options.timeout != defaults['timeout']: | ||||
sys.stderr.write( | ||||
'warning: --timeout option ignored with --debug\n') | ||||
|
r27141 | if options.slowtimeout != defaults['slowtimeout']: | ||
sys.stderr.write( | ||||
'warning: --slowtimeout option ignored with --debug\n') | ||||
|
r9707 | options.timeout = 0 | ||
|
r27141 | options.slowtimeout = 0 | ||
|
r9028 | if options.py3k_warnings: | ||
|
r25158 | if PYTHON3: | ||
parser.error( | ||||
|
r32353 | '--py3k-warnings can only be used on Python 2.7') | ||
|
r28582 | if options.with_python3: | ||
if PYTHON3: | ||||
parser.error('--with-python3 cannot be used when executing with ' | ||||
'Python 3') | ||||
|
r28645 | options.with_python3 = canonpath(options.with_python3) | ||
|
r28582 | # Verify Python3 executable is acceptable. | ||
proc = subprocess.Popen([options.with_python3, b'--version'], | ||||
stdout=subprocess.PIPE, | ||||
stderr=subprocess.STDOUT) | ||||
out, _err = proc.communicate() | ||||
ret = proc.wait() | ||||
if ret != 0: | ||||
parser.error('could not determine version of python 3') | ||||
if not out.startswith('Python '): | ||||
parser.error('unexpected output from python3 --version: %s' % | ||||
out) | ||||
vers = version.LooseVersion(out[len('Python '):]) | ||||
if vers < version.LooseVersion('3.5.0'): | ||||
parser.error('--with-python3 version must be 3.5.0 or greater; ' | ||||
'got %s' % out) | ||||
|
r9959 | if options.blacklist: | ||
|
r14493 | options.blacklist = parselistfiles(options.blacklist, 'blacklist') | ||
if options.whitelist: | ||||
|
r19279 | options.whitelisted = parselistfiles(options.whitelist, 'whitelist') | ||
|
r14493 | else: | ||
options.whitelisted = {} | ||||
|
r8091 | |||
|
r27396 | if options.showchannels: | ||
options.nodiff = True | ||||
|
r35188 | return options | ||
|
r5384 | |||
|
r5800 | def rename(src, dst): | ||
"""Like os.rename(), trade atomicity and opened files friendliness | ||||
for existing destination support. | ||||
""" | ||||
shutil.copy(src, dst) | ||||
os.remove(src) | ||||
|
r25045 | _unified_diff = difflib.unified_diff | ||
|
r25159 | if PYTHON3: | ||
|
r25045 | import functools | ||
_unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff) | ||||
|
r21521 | def getdiff(expected, output, ref, err): | ||
|
r21022 | servefail = False | ||
|
r21521 | lines = [] | ||
|
r25045 | for line in _unified_diff(expected, output, ref, err): | ||
if line.startswith(b'+++') or line.startswith(b'---'): | ||||
line = line.replace(b'\\', b'/') | ||||
if line.endswith(b' \n'): | ||||
line = line[:-2] + b'\n' | ||||
|
r21521 | lines.append(line) | ||
|
r21022 | if not servefail and line.startswith( | ||
|
r25045 | b'+ abort: child process failed to start'): | ||
|
r21022 | servefail = True | ||
|
r21521 | return servefail, lines | ||
|
r2110 | |||
|
r19250 | verbose = False | ||
def vlog(*msg): | ||||
|
r21535 | """Log only when in verbose mode.""" | ||
if verbose is False: | ||||
return | ||||
return log(*msg) | ||||
|
r19250 | |||
|
r22044 | # Bytes that break XML even in a CDATA block: control characters 0-31 | ||
# sans \t, \n and \r | ||||
|
r25051 | CDATA_EVIL = re.compile(br"[\000-\010\013\014\016-\037]") | ||
|
r22044 | |||
|
r31829 | # Match feature conditionalized output lines in the form, capturing the feature | ||
# list in group 2, and the preceeding line output in group 1: | ||||
# | ||||
# output..output (feature !)\n | ||||
|
r34445 | optline = re.compile(b'(.*) \((.+?) !\)\n$') | ||
|
r31829 | |||
|
r22044 | def cdatasafe(data): | ||
"""Make a string safe to include in a CDATA block. | ||||
Certain control characters are illegal in a CDATA block, and | ||||
there's no way to include a ]]> in a CDATA either. This function | ||||
replaces illegal bytes with ? and adds a space between the ]] so | ||||
that it won't break the CDATA block. | ||||
""" | ||||
|
r25051 | return CDATA_EVIL.sub(b'?', data).replace(b']]>', b'] ]>') | ||
|
r22044 | |||
|
r19251 | def log(*msg): | ||
|
r21535 | """Log something to stdout. | ||
Arguments are strings to print. | ||||
""" | ||||
|
r25046 | with iolock: | ||
if verbose: | ||||
print(verbose, end=' ') | ||||
for m in msg: | ||||
print(m, end=' ') | ||||
print() | ||||
sys.stdout.flush() | ||||
|
r19251 | |||
|
r33931 | def highlightdiff(line, color): | ||
if not color: | ||||
return line | ||||
assert pygmentspresent | ||||
|
r33932 | return pygments.highlight(line.decode('latin1'), difflexer, | ||
terminal256formatter).encode('latin1') | ||||
|
r33931 | |||
def highlightmsg(msg, color): | ||||
if not color: | ||||
return msg | ||||
assert pygmentspresent | ||||
return pygments.highlight(msg, runnerlexer, runnerformatter) | ||||
|
r14821 | def terminate(proc): | ||
|
r32303 | """Terminate subprocess""" | ||
|
r14821 | vlog('# Terminating process %d' % proc.pid) | ||
try: | ||||
|
r32303 | proc.terminate() | ||
|
r14821 | except OSError: | ||
pass | ||||
|
r19263 | def killdaemons(pidfile): | ||
|
r29485 | import killdaemons as killmod | ||
|
r19263 | return killmod.killdaemons(pidfile, tryhard=False, remove=True, | ||
|
r17464 | logfn=vlog) | ||
|
r10336 | |||
|
r21488 | class Test(unittest.TestCase): | ||
|
r21309 | """Encapsulates a single, runnable test. | ||
|
r21497 | While this class conforms to the unittest.TestCase API, it differs in that | ||
instances need to be instantiated manually. (Typically, unittest.TestCase | ||||
classes are instantiated automatically by scanning modules.) | ||||
|
r21309 | """ | ||
|
r21296 | |||
|
r21380 | # Status code reserved for skipped tests (used by hghave). | ||
SKIPPED_STATUS = 80 | ||||
|
r32716 | def __init__(self, path, outputdir, tmpdir, keeptmpdir=False, | ||
|
r21521 | debug=False, | ||
|
r34265 | timeout=None, | ||
startport=None, extraconfigopts=None, | ||||
|
r28099 | py3kwarnings=False, shell=None, hgcommand=None, | ||
|
r34265 | slowtimeout=None, usechg=False, | ||
|
r30986 | useipv6=False): | ||
|
r21502 | """Create a test from parameters. | ||
path is the full path to the file defining the test. | ||||
|
r21338 | |||
|
r21504 | tmpdir is the main temporary directory to use for this test. | ||
|
r21505 | |||
|
r21509 | keeptmpdir determines whether to keep the test's temporary directory | ||
after execution. It defaults to removal (False). | ||||
|
r21510 | |||
debug mode will make the test execute verbosely, with unfiltered | ||||
output. | ||||
|
r21511 | |||
|
r21513 | timeout controls the maximum run time of the test. It is ignored when | ||
|
r27141 | debug is True. See slowtimeout for tests with #require slow. | ||
slowtimeout overrides timeout if the test has #require slow. | ||||
|
r21514 | |||
startport controls the starting port number to use for this test. Each | ||||
test will reserve 3 port numbers for execution. It is the caller's | ||||
responsibility to allocate a non-overlapping port range to Test | ||||
instances. | ||||
|
r21515 | |||
extraconfigopts is an iterable of extra hgrc config options. Values | ||||
must have the form "key=value" (something understood by hgrc). Values | ||||
of the form "foo.key=value" will result in "[foo] key=value". | ||||
|
r21516 | |||
py3kwarnings enables Py3k warnings. | ||||
|
r21517 | |||
shell is the shell to execute tests in. | ||||
|
r21502 | """ | ||
|
r34265 | if timeout is None: | ||
timeout = defaults['timeout'] | ||||
if startport is None: | ||||
startport = defaults['port'] | ||||
if slowtimeout is None: | ||||
slowtimeout = defaults['slowtimeout'] | ||||
|
r25039 | self.path = path | ||
self.bname = os.path.basename(path) | ||||
|
r25162 | self.name = _strpath(self.bname) | ||
|
r21502 | self._testdir = os.path.dirname(path) | ||
|
r32716 | self._outputdir = outputdir | ||
|
r32317 | self._tmpname = os.path.basename(path) | ||
|
r32716 | self.errpath = os.path.join(self._outputdir, b'%s.err' % self.bname) | ||
|
r21435 | |||
|
r25039 | self._threadtmp = tmpdir | ||
|
r21509 | self._keeptmpdir = keeptmpdir | ||
|
r21510 | self._debug = debug | ||
|
r21513 | self._timeout = timeout | ||
|
r27141 | self._slowtimeout = slowtimeout | ||
|
r21514 | self._startport = startport | ||
|
r21515 | self._extraconfigopts = extraconfigopts or [] | ||
|
r21516 | self._py3kwarnings = py3kwarnings | ||
|
r25161 | self._shell = _bytespath(shell) | ||
|
r28099 | self._hgcommand = hgcommand or b'hg' | ||
|
r28620 | self._usechg = usechg | ||
|
r31003 | self._useipv6 = useipv6 | ||
|
r21520 | |||
self._aborted = False | ||||
|
r21319 | self._daemonpids = [] | ||
|
r21447 | self._finished = None | ||
|
r21449 | self._ret = None | ||
self._out = None | ||||
|
r21453 | self._skipped = None | ||
|
r21454 | self._testtmp = None | ||
|
r28620 | self._chgsockdir = None | ||
|
r21447 | |||
|
r32980 | self._refout = self.readrefout() | ||
def readrefout(self): | ||||
"""read reference output""" | ||||
|
r21318 | # If we're not in --debug mode and reference output file exists, | ||
# check test output against it. | ||||
|
r32980 | if self._debug: | ||
return None # to match "out is None" | ||||
|
r21521 | elif os.path.exists(self.refpath): | ||
|
r32980 | with open(self.refpath, 'rb') as f: | ||
return f.read().splitlines(True) | ||||
|
r21318 | else: | ||
|
r32980 | return [] | ||
|
r21318 | |||
|
r24965 | # needed to get base class __repr__ running | ||
@property | ||||
def _testMethodName(self): | ||||
return self.name | ||||
|
r21463 | def __str__(self): | ||
return self.name | ||||
|
r21488 | def shortDescription(self): | ||
return self.name | ||||
|
r21446 | def setUp(self): | ||
"""Tasks to perform before run().""" | ||||
|
r21447 | self._finished = False | ||
|
r21449 | self._ret = None | ||
self._out = None | ||||
|
r21453 | self._skipped = None | ||
|
r21446 | |||
|
r21497 | try: | ||
os.mkdir(self._threadtmp) | ||||
|
r25031 | except OSError as e: | ||
|
r21497 | if e.errno != errno.EEXIST: | ||
raise | ||||
|
r32317 | name = self._tmpname | ||
|
r28620 | self._testtmp = os.path.join(self._threadtmp, name) | ||
|
r21454 | os.mkdir(self._testtmp) | ||
|
r21457 | # Remove any previous output files. | ||
|
r21507 | if os.path.exists(self.errpath): | ||
|
r24332 | try: | ||
os.remove(self.errpath) | ||||
|
r25031 | except OSError as e: | ||
|
r24332 | # We might have raced another test to clean up a .err | ||
# file, so ignore ENOENT when removing a previous .err | ||||
# file. | ||||
if e.errno != errno.ENOENT: | ||||
raise | ||||
|
r21457 | |||
|
r28620 | if self._usechg: | ||
self._chgsockdir = os.path.join(self._threadtmp, | ||||
b'%s.chgsock' % name) | ||||
os.mkdir(self._chgsockdir) | ||||
|
r21488 | def run(self, result): | ||
|
r21536 | """Run this test and report results against a TestResult instance.""" | ||
# This function is extremely similar to unittest.TestCase.run(). Once | ||||
# we require Python 2.7 (or at least its version of unittest), this | ||||
# function can largely go away. | ||||
|
r21521 | self._result = result | ||
|
r21488 | result.startTest(self) | ||
try: | ||||
try: | ||||
self.setUp() | ||||
except (KeyboardInterrupt, SystemExit): | ||||
|
r21520 | self._aborted = True | ||
|
r21488 | raise | ||
except Exception: | ||||
result.addError(self, sys.exc_info()) | ||||
return | ||||
success = False | ||||
try: | ||||
self.runTest() | ||||
except KeyboardInterrupt: | ||||
|
r21520 | self._aborted = True | ||
|
r21488 | raise | ||
|
r32932 | except unittest.SkipTest as e: | ||
|
r21488 | result.addSkip(self, str(e)) | ||
|
r21997 | # The base class will have already counted this as a | ||
# test we "ran", but we want to exclude skipped tests | ||||
# from those we count towards those run. | ||||
result.testsRun -= 1 | ||||
|
r25031 | except self.failureException as e: | ||
|
r21488 | # This differs from unittest in that we don't capture | ||
# the stack trace. This is for historical reasons and | ||||
|
r23139 | # this decision could be revisited in the future, | ||
|
r21488 | # especially for PythonTest instances. | ||
|
r21753 | if result.addFailure(self, str(e)): | ||
success = True | ||||
|
r21488 | except Exception: | ||
result.addError(self, sys.exc_info()) | ||||
else: | ||||
success = True | ||||
try: | ||||
self.tearDown() | ||||
except (KeyboardInterrupt, SystemExit): | ||||
|
r21520 | self._aborted = True | ||
|
r21488 | raise | ||
except Exception: | ||||
result.addError(self, sys.exc_info()) | ||||
success = False | ||||
if success: | ||||
result.addSuccess(self) | ||||
finally: | ||||
|
r21520 | result.stopTest(self, interrupted=self._aborted) | ||
|
r21488 | |||
def runTest(self): | ||||
|
r21383 | """Run this test instance. | ||
This will return a tuple describing the result of the test. | ||||
""" | ||||
|
r21514 | env = self._getenv() | ||
|
r33121 | self._genrestoreenv(env) | ||
|
r21319 | self._daemonpids.append(env['DAEMON_PIDS']) | ||
|
r21382 | self._createhgrc(env['HGRCPATH']) | ||
|
r21300 | |||
|
r21435 | vlog('# Test', self.name) | ||
|
r21337 | |||
|
r24516 | ret, out = self._run(env) | ||
|
r21500 | self._finished = True | ||
self._ret = ret | ||||
self._out = out | ||||
|
r21305 | |||
|
r21326 | def describe(ret): | ||
if ret < 0: | ||||
return 'killed by signal: %d' % -ret | ||||
return 'returned error code %d' % ret | ||||
|
r21453 | self._skipped = False | ||
|
r21336 | |||
|
r21380 | if ret == self.SKIPPED_STATUS: | ||
|
r21324 | if out is None: # Debug mode, nothing to parse. | ||
missing = ['unknown'] | ||||
failed = None | ||||
else: | ||||
|
r21379 | missing, failed = TTest.parsehghaveoutput(out) | ||
|
r21324 | |||
if not missing: | ||||
|
r22292 | missing = ['skipped'] | ||
|
r21324 | |||
if failed: | ||||
|
r21523 | self.fail('hg have failed checking for %s' % failed[-1]) | ||
|
r21324 | else: | ||
|
r21453 | self._skipped = True | ||
|
r32932 | raise unittest.SkipTest(missing[-1]) | ||
|
r21325 | elif ret == 'timeout': | ||
|
r21523 | self.fail('timed out') | ||
|
r21522 | elif ret is False: | ||
|
r32934 | self.fail('no result code from test') | ||
|
r21326 | elif out != self._refout: | ||
|
r21614 | # Diff generation may rely on written .err file. | ||
if (ret != 0 or out != self._refout) and not self._skipped \ | ||||
and not self._debug: | ||||
f = open(self.errpath, 'wb') | ||||
for line in out: | ||||
f.write(line) | ||||
f.close() | ||||
|
r21521 | # The result object handles diff calculation for us. | ||
|
r21763 | if self._result.addOutputMismatch(self, ret, out, self._refout): | ||
# change was accepted, skip failing | ||||
return | ||||
|
r21521 | |||
|
r21326 | if ret: | ||
|
r21521 | msg = 'output changed and ' + describe(ret) | ||
|
r21326 | else: | ||
|
r21521 | msg = 'output changed' | ||
|
r21326 | |||
|
r21523 | self.fail(msg) | ||
|
r21327 | elif ret: | ||
|
r21523 | self.fail(describe(ret)) | ||
|
r21324 | |||
|
r21446 | def tearDown(self): | ||
"""Tasks to perform after run().""" | ||||
|
r21456 | for entry in self._daemonpids: | ||
killdaemons(entry) | ||||
self._daemonpids = [] | ||||
|
r26422 | if self._keeptmpdir: | ||
log('\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s' % | ||||
|
r28284 | (self._testtmp.decode('utf-8'), | ||
self._threadtmp.decode('utf-8'))) | ||||
|
r26422 | else: | ||
|
r21461 | shutil.rmtree(self._testtmp, True) | ||
|
r21497 | shutil.rmtree(self._threadtmp, True) | ||
|
r21454 | |||
|
r28620 | if self._usechg: | ||
# chgservers will stop automatically after they find the socket | ||||
# files are deleted | ||||
shutil.rmtree(self._chgsockdir, True) | ||||
|
r21455 | if (self._ret != 0 or self._out != self._refout) and not self._skipped \ | ||
|
r21510 | and not self._debug and self._out: | ||
|
r21507 | f = open(self.errpath, 'wb') | ||
|
r21455 | for line in self._out: | ||
f.write(line) | ||||
f.close() | ||||
|
r24926 | vlog("# Ret was:", self._ret, '(%s)' % self.name) | ||
|
r21452 | |||
|
r24516 | def _run(self, env): | ||
|
r21339 | # This should be implemented in child classes to run tests. | ||
|
r32932 | raise unittest.SkipTest('unknown test type') | ||
|
r21296 | |||
|
r21520 | def abort(self): | ||
"""Terminate execution of this test.""" | ||||
self._aborted = True | ||||
|
r28169 | def _portmap(self, i): | ||
|
r28284 | offset = b'' if i == 0 else b'%d' % i | ||
|
r28169 | return (br':%d\b' % (self._startport + i), b':$HGPORT%s' % offset) | ||
|
r21454 | def _getreplacements(self): | ||
|
r21536 | """Obtain a mapping of text replacements to apply to test output. | ||
Test output needs to be normalized so it can be compared to expected | ||||
output. This function defines how some of that normalization will | ||||
occur. | ||||
""" | ||||
|
r21298 | r = [ | ||
|
r28169 | # This list should be parallel to defineport in _getenv | ||
self._portmap(0), | ||||
self._portmap(1), | ||||
self._portmap(2), | ||||
|
r25041 | (br'(?m)^(saved backup bundle to .*\.hg)( \(glob\))?$', | ||
br'\1 (glob)'), | ||||
|
r31008 | (br'([^0-9])%s' % re.escape(self._localip()), br'\1$LOCALIP'), | ||
|
r31741 | (br'\bHG_TXNID=TXN:[a-f0-9]{40}\b', br'HG_TXNID=TXN:$ID$'), | ||
|
r21298 | ] | ||
|
r28055 | r.append((self._escapepath(self._testtmp), b'$TESTTMP')) | ||
|
r21298 | |||
|
r35068 | testdir = os.path.dirname(self.path) | ||
|
r35090 | replacementfile = os.path.join(testdir, b'common-pattern.py') | ||
|
r35068 | |||
if os.path.exists(replacementfile): | ||||
data = {} | ||||
|
r35091 | with open(replacementfile, mode='rb') as source: | ||
# the intermediate 'compile' step help with debugging | ||||
code = compile(source.read(), replacementfile, 'exec') | ||||
exec(code, data) | ||||
r.extend(data.get('substitutions', ())) | ||||
|
r28055 | return r | ||
def _escapepath(self, p): | ||||
|
r21298 | if os.name == 'nt': | ||
|
r28055 | return ( | ||
|
r25041 | (b''.join(c.isalpha() and b'[%s%s]' % (c.lower(), c.upper()) or | ||
c in b'/\\' and br'[/\\]' or c.isdigit() and c or b'\\' + c | ||||
|
r28055 | for c in p)) | ||
) | ||||
|
r21298 | else: | ||
|
r28055 | return re.escape(p) | ||
|
r21298 | |||
|
r31006 | def _localip(self): | ||
if self._useipv6: | ||||
return b'::1' | ||||
else: | ||||
return b'127.0.0.1' | ||||
|
r33121 | def _genrestoreenv(self, testenv): | ||
"""Generate a script that can be used by tests to restore the original | ||||
environment.""" | ||||
# Put the restoreenv script inside self._threadtmp | ||||
scriptpath = os.path.join(self._threadtmp, b'restoreenv.sh') | ||||
testenv['HGTEST_RESTOREENV'] = scriptpath | ||||
# Only restore environment variable names that the shell allows | ||||
# us to export. | ||||
|
r33141 | name_regex = re.compile('^[a-zA-Z][a-zA-Z0-9_]*$') | ||
|
r33121 | |||
|
r33198 | # Do not restore these variables; otherwise tests would fail. | ||
reqnames = {'PYTHON', 'TESTDIR', 'TESTTMP'} | ||||
|
r33121 | with open(scriptpath, 'w') as envf: | ||
|
r33198 | for name, value in origenviron.items(): | ||
|
r33121 | if not name_regex.match(name): | ||
# Skip environment variables with unusual names not | ||||
# allowed by most shells. | ||||
continue | ||||
|
r33198 | if name in reqnames: | ||
continue | ||||
|
r33121 | envf.write('%s=%s\n' % (name, shellquote(value))) | ||
for name in testenv: | ||||
|
r33198 | if name in origenviron or name in reqnames: | ||
|
r33121 | continue | ||
envf.write('unset %s\n' % (name,)) | ||||
|
r21514 | def _getenv(self): | ||
|
r21536 | """Obtain environment variables to use during test execution.""" | ||
|
r28169 | def defineport(i): | ||
offset = '' if i == 0 else '%s' % i | ||||
env["HGPORT%s" % offset] = '%s' % (self._startport + i) | ||||
|
r21299 | env = os.environ.copy() | ||
|
r32302 | env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase') | ||
|
r31950 | env['HGEMITWARNINGS'] = '1' | ||
|
r21454 | env['TESTTMP'] = self._testtmp | ||
env['HOME'] = self._testtmp | ||||
|
r28169 | # This number should match portneeded in _getport | ||
|
r28170 | for port in xrange(3): | ||
|
r28169 | # This list should be parallel to _portmap in _getreplacements | ||
defineport(port) | ||||
|
r25034 | env["HGRCPATH"] = os.path.join(self._threadtmp, b'.hgrc') | ||
env["DAEMON_PIDS"] = os.path.join(self._threadtmp, b'daemon.pids') | ||||
|
r23347 | env["HGEDITOR"] = ('"' + sys.executable + '"' | ||
+ ' -c "import sys; sys.exit(0)"') | ||||
|
r21299 | env["HGMERGE"] = "internal:merge" | ||
env["HGUSER"] = "test" | ||||
env["HGENCODING"] = "ascii" | ||||
env["HGENCODINGMODE"] = "strict" | ||||
|
r31003 | env['HGIPV6'] = str(int(self._useipv6)) | ||
|
r21299 | |||
|
r31006 | # LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw | ||
# IP addresses. | ||||
env['LOCALIP'] = self._localip() | ||||
|
r21299 | # Reset some environment variables to well-known values so that | ||
# the tests produce repeatable output. | ||||
env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C' | ||||
env['TZ'] = 'GMT' | ||||
env["EMAIL"] = "Foo Bar <foo.bar@example.com>" | ||||
env['COLUMNS'] = '80' | ||||
env['TERM'] = 'xterm' | ||||
for k in ('HG HGPROF CDPATH GREP_OPTIONS http_proxy no_proxy ' + | ||||
|
r31635 | 'HGPLAIN HGPLAINEXCEPT EDITOR VISUAL PAGER ' + | ||
|
r30716 | 'NO_PROXY CHGDEBUG').split(): | ||
|
r21299 | if k in env: | ||
del env[k] | ||||
# unset env related to hooks | ||||
for k in env.keys(): | ||||
if k.startswith('HG_'): | ||||
del env[k] | ||||
|
r28620 | if self._usechg: | ||
env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server') | ||||
|
r21299 | return env | ||
|
r21382 | def _createhgrc(self, path): | ||
|
r21536 | """Create an hgrc file for this test.""" | ||
|
r21916 | hgrc = open(path, 'wb') | ||
|
r25034 | hgrc.write(b'[ui]\n') | ||
hgrc.write(b'slash = True\n') | ||||
hgrc.write(b'interactive = False\n') | ||||
hgrc.write(b'mergemarkers = detailed\n') | ||||
hgrc.write(b'promptecho = True\n') | ||||
hgrc.write(b'[defaults]\n') | ||||
hgrc.write(b'[devel]\n') | ||||
|
r25290 | hgrc.write(b'all-warnings = true\n') | ||
r32410 | hgrc.write(b'default-date = 0 0\n') | |||
|
r25034 | hgrc.write(b'[largefiles]\n') | ||
hgrc.write(b'usercache = %s\n' % | ||||
(os.path.join(self._testtmp, b'.cache/largefiles'))) | ||||
|
r31009 | hgrc.write(b'[web]\n') | ||
hgrc.write(b'address = localhost\n') | ||||
|
r31227 | hgrc.write(b'ipv6 = %s\n' % str(self._useipv6).encode('ascii')) | ||
|
r23388 | |||
|
r21515 | for opt in self._extraconfigopts: | ||
section, key = opt.split('.', 1) | ||||
assert '=' in key, ('extra config opt %s must ' | ||||
'have an = for assignment' % opt) | ||||
|
r25034 | hgrc.write(b'[%s]\n%s\n' % (section, key)) | ||
|
r21382 | hgrc.close() | ||
|
r21523 | def fail(self, msg): | ||
|
r21522 | # unittest differentiates between errored and failed. | ||
# Failed is denoted by AssertionError (by default at least). | ||||
raise AssertionError(msg) | ||||
|
r21323 | |||
|
r24516 | def _runcommand(self, cmd, env, normalizenewlines=False): | ||
|
r24508 | """Run command in a sub-process, capturing the output (stdout and | ||
stderr). | ||||
Return a tuple (exitcode, output). output is None in debug mode. | ||||
""" | ||||
|
r24509 | if self._debug: | ||
proc = subprocess.Popen(cmd, shell=True, cwd=self._testtmp, | ||||
env=env) | ||||
|
r24508 | ret = proc.wait() | ||
return (ret, None) | ||||
|
r24509 | proc = Popen4(cmd, self._testtmp, self._timeout, env) | ||
|
r24508 | def cleanup(): | ||
terminate(proc) | ||||
ret = proc.wait() | ||||
if ret == 0: | ||||
ret = signal.SIGTERM << 8 | ||||
killdaemons(env['DAEMON_PIDS']) | ||||
return ret | ||||
output = '' | ||||
proc.tochild.close() | ||||
try: | ||||
output = proc.fromchild.read() | ||||
except KeyboardInterrupt: | ||||
vlog('# Handling keyboard interrupt') | ||||
cleanup() | ||||
raise | ||||
ret = proc.wait() | ||||
|
r25177 | if wifexited(ret): | ||
|
r24508 | ret = os.WEXITSTATUS(ret) | ||
if proc.timeout: | ||||
ret = 'timeout' | ||||
if ret: | ||||
killdaemons(env['DAEMON_PIDS']) | ||||
|
r24516 | for s, r in self._getreplacements(): | ||
|
r24508 | output = re.sub(s, r, output) | ||
|
r24510 | |||
if normalizenewlines: | ||||
output = output.replace('\r\n', '\n') | ||||
|
r24508 | return ret, output.splitlines(True) | ||
|
r21296 | class PythonTest(Test): | ||
"""A Python-based test.""" | ||||
|
r21501 | |||
@property | ||||
|
r21521 | def refpath(self): | ||
|
r25058 | return os.path.join(self._testdir, b'%s.out' % self.bname) | ||
|
r21501 | |||
|
r24516 | def _run(self, env): | ||
|
r25058 | py3kswitch = self._py3kwarnings and b' -3' or b'' | ||
cmd = b'%s%s "%s"' % (PYTHON, py3kswitch, self.path) | ||||
|
r21311 | vlog("# Running", cmd) | ||
|
r24510 | normalizenewlines = os.name == 'nt' | ||
|
r24516 | result = self._runcommand(cmd, env, | ||
|
r24510 | normalizenewlines=normalizenewlines) | ||
|
r21520 | if self._aborted: | ||
raise KeyboardInterrupt() | ||||
return result | ||||
|
r21311 | |||
|
r29518 | # Some glob patterns apply only in some circumstances, so the script | ||
# might want to remove (glob) annotations that otherwise should be | ||||
# retained. | ||||
|
r23352 | checkcodeglobpats = [ | ||
|
r29518 | # On Windows it looks like \ doesn't require a (glob), but we know | ||
# better. | ||||
|
r25059 | re.compile(br'^pushing to \$TESTTMP/.*[^)]$'), | ||
re.compile(br'^moving \S+/.*[^)]$'), | ||||
|
r29518 | re.compile(br'^pulling from \$TESTTMP/.*[^)]$'), | ||
# Not all platforms have 127.0.0.1 as loopback (though most do), | ||||
# so we always glob that too. | ||||
|
r31673 | re.compile(br'.*\$LOCALIP.*$'), | ||
|
r23352 | ] | ||
|
r25036 | bchr = chr | ||
|
r25159 | if PYTHON3: | ||
|
r25036 | bchr = lambda x: bytes([x]) | ||
|
r21296 | class TTest(Test): | ||
"""A "t test" is a test backed by a .t file.""" | ||||
|
r28284 | SKIPPED_PREFIX = b'skipped: ' | ||
FAILED_PREFIX = b'hghave check failed: ' | ||||
|
r25041 | NEEDESCAPE = re.compile(br'[\x00-\x08\x0b-\x1f\x7f-\xff]').search | ||
|
r21384 | |||
|
r25041 | ESCAPESUB = re.compile(br'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub | ||
ESCAPEMAP = dict((bchr(i), br'\x%02x' % i) for i in range(256)) | ||||
ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'}) | ||||
|
r21381 | |||
|
r32317 | def __init__(self, path, *args, **kwds): | ||
# accept an extra "case" parameter | ||||
case = None | ||||
if 'case' in kwds: | ||||
case = kwds.pop('case') | ||||
self._case = case | ||||
self._allcases = parsettestcases(path) | ||||
super(TTest, self).__init__(path, *args, **kwds) | ||||
if case: | ||||
self.name = '%s (case %s)' % (self.name, _strpath(case)) | ||||
self.errpath = b'%s.%s.err' % (self.errpath[:-4], case) | ||||
self._tmpname += b'-%s' % case | ||||
|
r21501 | @property | ||
|
r21521 | def refpath(self): | ||
|
r25041 | return os.path.join(self._testdir, self.bname) | ||
|
r21501 | |||
|
r24516 | def _run(self, env): | ||
|
r21916 | f = open(self.path, 'rb') | ||
|
r21313 | lines = f.readlines() | ||
f.close() | ||||
|
r32981 | # .t file is both reference output and the test input, keep reference | ||
# output updated with the the test input. This avoids some race | ||||
# conditions where the reference output does not match the actual test. | ||||
if self._refout is not None: | ||||
self._refout = lines | ||||
|
r21454 | salt, script, after, expected = self._parsetest(lines) | ||
|
r21313 | |||
# Write out the generated script. | ||||
|
r25041 | fname = b'%s.sh' % self._testtmp | ||
|
r21916 | f = open(fname, 'wb') | ||
|
r21313 | for l in script: | ||
f.write(l) | ||||
f.close() | ||||
|
r25041 | cmd = b'%s "%s"' % (self._shell, fname) | ||
|
r21313 | vlog("# Running", cmd) | ||
|
r24516 | exitcode, output = self._runcommand(cmd, env) | ||
|
r21520 | |||
if self._aborted: | ||||
raise KeyboardInterrupt() | ||||
|
r21313 | # Do not merge output if skipped. Return hghave message instead. | ||
# Similarly, with --debug, output is None. | ||||
|
r21380 | if exitcode == self.SKIPPED_STATUS or output is None: | ||
|
r21313 | return exitcode, output | ||
|
r21314 | return self._processoutput(exitcode, output, salt, after, expected) | ||
|
r21296 | |||
|
r21454 | def _hghave(self, reqs): | ||
|
r21312 | # TODO do something smarter when all other uses of hghave are gone. | ||
|
r25728 | runtestdir = os.path.abspath(os.path.dirname(_bytespath(__file__))) | ||
tdir = runtestdir.replace(b'\\', b'/') | ||||
|
r25041 | proc = Popen4(b'%s -c "%s/hghave %s"' % | ||
(self._shell, tdir, b' '.join(reqs)), | ||||
|
r23933 | self._testtmp, 0, self._getenv()) | ||
|
r21312 | stdout, stderr = proc.communicate() | ||
ret = proc.wait() | ||||
|
r25177 | if wifexited(ret): | ||
|
r21312 | ret = os.WEXITSTATUS(ret) | ||
if ret == 2: | ||||
|
r28699 | print(stdout.decode('utf-8')) | ||
|
r21312 | sys.exit(1) | ||
|
r27141 | if ret != 0: | ||
|
r27564 | return False, stdout | ||
|
r27141 | |||
|
r34266 | if b'slow' in reqs: | ||
|
r27141 | self._timeout = self._slowtimeout | ||
|
r27564 | return True, None | ||
|
r21312 | |||
|
r32317 | def _iftest(self, args): | ||
# implements "#if" | ||||
reqs = [] | ||||
for arg in args: | ||||
if arg.startswith(b'no-') and arg[3:] in self._allcases: | ||||
if arg[3:] == self._case: | ||||
return False | ||||
elif arg in self._allcases: | ||||
if arg != self._case: | ||||
return False | ||||
else: | ||||
reqs.append(arg) | ||||
return self._hghave(reqs)[0] | ||||
|
r21454 | def _parsetest(self, lines): | ||
|
r21312 | # We generate a shell script which outputs unique markers to line | ||
# up script results with our source. These markers include input | ||||
# line number and the last return code. | ||||
|
r25041 | salt = b"SALT%d" % time.time() | ||
|
r21312 | def addsalt(line, inpython): | ||
if inpython: | ||||
|
r25041 | script.append(b'%s %d 0\n' % (salt, line)) | ||
|
r21312 | else: | ||
|
r25041 | script.append(b'echo %s %d $?\n' % (salt, line)) | ||
|
r21312 | |||
script = [] | ||||
# After we run the shell script, we re-unify the script output | ||||
# with non-active parts of the source, with synchronization by our | ||||
# SALT line number markers. The after table contains the non-active | ||||
# components, ordered by line number. | ||||
after = {} | ||||
# Expected shell script output. | ||||
expected = {} | ||||
pos = prepos = -1 | ||||
# True or False when in a true or false conditional section | ||||
skipping = None | ||||
# We keep track of whether or not we're in a Python block so we | ||||
# can generate the surrounding doctest magic. | ||||
inpython = False | ||||
|
r21510 | if self._debug: | ||
|
r25060 | script.append(b'set -x\n') | ||
|
r28099 | if self._hgcommand != b'hg': | ||
script.append(b'alias hg="%s"\n' % self._hgcommand) | ||||
|
r21312 | if os.getenv('MSYSTEM'): | ||
|
r25060 | script.append(b'alias pwd="pwd -W"\n') | ||
|
r21312 | |||
|
r28812 | n = 0 | ||
|
r21312 | for n, l in enumerate(lines): | ||
|
r25035 | if not l.endswith(b'\n'): | ||
l += b'\n' | ||||
if l.startswith(b'#require'): | ||||
|
r22045 | lsplit = l.split() | ||
|
r25035 | if len(lsplit) < 2 or lsplit[0] != b'#require': | ||
|
r22045 | after.setdefault(pos, []).append(' !!! invalid #require\n') | ||
|
r27564 | haveresult, message = self._hghave(lsplit[1:]) | ||
if not haveresult: | ||||
script = [b'echo "%s"\nexit 80\n' % message] | ||||
|
r22045 | break | ||
after.setdefault(pos, []).append(l) | ||||
|
r25035 | elif l.startswith(b'#if'): | ||
|
r21312 | lsplit = l.split() | ||
|
r25035 | if len(lsplit) < 2 or lsplit[0] != b'#if': | ||
|
r21312 | after.setdefault(pos, []).append(' !!! invalid #if\n') | ||
if skipping is not None: | ||||
after.setdefault(pos, []).append(' !!! nested #if\n') | ||||
|
r32317 | skipping = not self._iftest(lsplit[1:]) | ||
|
r21312 | after.setdefault(pos, []).append(l) | ||
|
r25035 | elif l.startswith(b'#else'): | ||
|
r21312 | if skipping is None: | ||
after.setdefault(pos, []).append(' !!! missing #if\n') | ||||
skipping = not skipping | ||||
after.setdefault(pos, []).append(l) | ||||
|
r25035 | elif l.startswith(b'#endif'): | ||
|
r21312 | if skipping is None: | ||
after.setdefault(pos, []).append(' !!! missing #if\n') | ||||
skipping = None | ||||
after.setdefault(pos, []).append(l) | ||||
elif skipping: | ||||
after.setdefault(pos, []).append(l) | ||||
|
r25035 | elif l.startswith(b' >>> '): # python inlines | ||
|
r21312 | after.setdefault(pos, []).append(l) | ||
prepos = pos | ||||
pos = n | ||||
if not inpython: | ||||
# We've just entered a Python block. Add the header. | ||||
inpython = True | ||||
addsalt(prepos, False) # Make sure we report the exit code. | ||||
|
r25058 | script.append(b'%s -m heredoctest <<EOF\n' % PYTHON) | ||
|
r21312 | addsalt(n, True) | ||
script.append(l[2:]) | ||||
|
r25035 | elif l.startswith(b' ... '): # python inlines | ||
|
r21312 | after.setdefault(prepos, []).append(l) | ||
script.append(l[2:]) | ||||
|
r25035 | elif l.startswith(b' $ '): # commands | ||
|
r21312 | if inpython: | ||
|
r25060 | script.append(b'EOF\n') | ||
|
r21312 | inpython = False | ||
after.setdefault(pos, []).append(l) | ||||
prepos = pos | ||||
pos = n | ||||
addsalt(n, False) | ||||
cmd = l[4:].split() | ||||
|
r25060 | if len(cmd) == 2 and cmd[0] == b'cd': | ||
l = b' $ cd %s || exit 1\n' % cmd[1] | ||||
|
r21312 | script.append(l[4:]) | ||
|
r25035 | elif l.startswith(b' > '): # continuations | ||
|
r21312 | after.setdefault(prepos, []).append(l) | ||
script.append(l[4:]) | ||||
|
r25035 | elif l.startswith(b' '): # results | ||
|
r21312 | # Queue up a list of expected results. | ||
expected.setdefault(pos, []).append(l[2:]) | ||||
else: | ||||
if inpython: | ||||
|
r25060 | script.append(b'EOF\n') | ||
|
r21312 | inpython = False | ||
# Non-command/result. Queue up for merged output. | ||||
after.setdefault(pos, []).append(l) | ||||
if inpython: | ||||
|
r25060 | script.append(b'EOF\n') | ||
|
r21312 | if skipping is not None: | ||
after.setdefault(pos, []).append(' !!! missing #endif\n') | ||||
addsalt(n + 1, False) | ||||
return salt, script, after, expected | ||||
|
r21314 | def _processoutput(self, exitcode, output, salt, after, expected): | ||
# Merge the script output back into a unified test. | ||||
warnonly = 1 # 1: not yet; 2: yes; 3: for sure not | ||||
if exitcode != 0: | ||||
warnonly = 3 | ||||
pos = -1 | ||||
postout = [] | ||||
for l in output: | ||||
lout, lcmd = l, None | ||||
if salt in l: | ||||
lout, lcmd = l.split(salt, 1) | ||||
|
r25388 | while lout: | ||
|
r25041 | if not lout.endswith(b'\n'): | ||
lout += b' (no-eol)\n' | ||||
|
r21314 | |||
# Find the expected output at the current position. | ||||
|
r28569 | els = [None] | ||
|
r21314 | if expected.get(pos, None): | ||
|
r28569 | els = expected[pos] | ||
i = 0 | ||||
|
r28701 | optional = [] | ||
|
r28569 | while i < len(els): | ||
el = els[i] | ||||
|
r33658 | r = self.linematch(el, lout) | ||
|
r28568 | if isinstance(r, str): | ||
if r == '+glob': | ||||
lout = el[:-1] + ' (glob)\n' | ||||
r = '' # Warn only this line. | ||||
elif r == '-glob': | ||||
lout = ''.join(el.rsplit(' (glob)', 1)) | ||||
r = '' # Warn only this line. | ||||
elif r == "retry": | ||||
postout.append(b' ' + el) | ||||
|
r28569 | els.pop(i) | ||
break | ||||
|
r28568 | else: | ||
log('\ninfo, unknown linematch result: %r\n' % r) | ||||
r = False | ||||
|
r28569 | if r: | ||
els.pop(i) | ||||
break | ||||
|
r31829 | if el: | ||
if el.endswith(b" (?)\n"): | ||||
optional.append(i) | ||||
else: | ||||
m = optline.match(el) | ||||
if m: | ||||
|
r33676 | conditions = [ | ||
c for c in m.group(2).split(b' ')] | ||||
|
r31829 | |||
|
r33935 | if not self._iftest(conditions): | ||
|
r31829 | optional.append(i) | ||
|
r28569 | i += 1 | ||
|
r21314 | if r: | ||
|
r28569 | if r == "retry": | ||
continue | ||||
|
r28701 | # clean up any optional leftovers | ||
for i in optional: | ||||
postout.append(b' ' + els[i]) | ||||
for i in reversed(optional): | ||||
del els[i] | ||||
|
r25041 | postout.append(b' ' + el) | ||
|
r21314 | else: | ||
|
r21384 | if self.NEEDESCAPE(lout): | ||
|
r25041 | lout = TTest._stringescape(b'%s (esc)\n' % | ||
lout.rstrip(b'\n')) | ||||
postout.append(b' ' + lout) # Let diff deal with it. | ||||
|
r21314 | if r != '': # If line failed. | ||
warnonly = 3 # for sure not | ||||
elif warnonly == 1: # Is "not yet" and line is warn only. | ||||
warnonly = 2 # Yes do warn. | ||||
|
r25388 | break | ||
|
r28317 | else: | ||
# clean up any optional leftovers | ||||
while expected.get(pos, None): | ||||
el = expected[pos].pop(0) | ||||
|
r31829 | if el: | ||
|
r33658 | if not el.endswith(b" (?)\n"): | ||
m = optline.match(el) | ||||
if m: | ||||
|
r33873 | conditions = [c for c in m.group(2).split(b' ')] | ||
|
r33658 | |||
|
r33935 | if self._iftest(conditions): | ||
|
r33658 | # Don't append as optional line | ||
continue | ||||
else: | ||||
|
r33659 | continue | ||
|
r28317 | postout.append(b' ' + el) | ||
|
r21314 | |||
if lcmd: | ||||
# Add on last return code. | ||||
ret = int(lcmd.split()[1]) | ||||
if ret != 0: | ||||
|
r25041 | postout.append(b' [%d]\n' % ret) | ||
|
r21314 | if pos in after: | ||
# Merge in non-active test bits. | ||||
postout += after.pop(pos) | ||||
pos = int(lcmd.split()[0]) | ||||
if pos in after: | ||||
postout += after.pop(pos) | ||||
if warnonly == 2: | ||||
exitcode = False # Set exitcode to warned. | ||||
return exitcode, postout | ||||
|
r21312 | |||
|
r21315 | @staticmethod | ||
|
r21316 | def rematch(el, l): | ||
try: | ||||
|
r35156 | el = b'(?:' + el + b')' | ||
|
r21316 | # use \Z to ensure that the regex matches to the end of the string | ||
if os.name == 'nt': | ||||
|
r25041 | return re.match(el + br'\r?\n\Z', l) | ||
return re.match(el + br'\n\Z', l) | ||||
|
r21316 | except re.error: | ||
# el is an invalid regex | ||||
return False | ||||
@staticmethod | ||||
|
r21317 | def globmatch(el, l): | ||
# The only supported special characters are * and ? plus / which also | ||||
# matches \ on windows. Escaping of these characters is supported. | ||||
|
r25041 | if el + b'\n' == l: | ||
|
r21317 | if os.altsep: | ||
# matching on "/" is not needed for this line | ||||
|
r23352 | for pat in checkcodeglobpats: | ||
if pat.match(el): | ||||
return True | ||||
|
r25041 | return b'-glob' | ||
|
r21317 | return True | ||
|
r31673 | el = el.replace(b'$LOCALIP', b'*') | ||
|
r21317 | i, n = 0, len(el) | ||
|
r25041 | res = b'' | ||
|
r21317 | while i < n: | ||
|
r25041 | c = el[i:i + 1] | ||
|
r21317 | i += 1 | ||
|
r25041 | if c == b'\\' and i < n and el[i:i + 1] in b'*?\\/': | ||
|
r21317 | res += el[i - 1:i + 1] | ||
i += 1 | ||||
|
r25041 | elif c == b'*': | ||
res += b'.*' | ||||
elif c == b'?': | ||||
res += b'.' | ||||
elif c == b'/' and os.altsep: | ||||
res += b'[/\\\\]' | ||||
|
r21317 | else: | ||
res += re.escape(c) | ||||
return TTest.rematch(res, l) | ||||
|
r33658 | def linematch(self, el, l): | ||
|
r25388 | retry = False | ||
|
r21315 | if el == l: # perfect match (fast) | ||
return True | ||||
if el: | ||||
|
r26612 | if el.endswith(b" (?)\n"): | ||
|
r25388 | retry = "retry" | ||
|
r28284 | el = el[:-5] + b"\n" | ||
|
r31829 | else: | ||
m = optline.match(el) | ||||
if m: | ||||
|
r33676 | conditions = [c for c in m.group(2).split(b' ')] | ||
|
r33658 | |||
|
r31829 | el = m.group(1) + b"\n" | ||
|
r33935 | if not self._iftest(conditions): | ||
|
r33658 | retry = "retry" # Not required by listed features | ||
|
r31829 | |||
|
r25041 | if el.endswith(b" (esc)\n"): | ||
|
r25159 | if PYTHON3: | ||
|
r25047 | el = el[:-7].decode('unicode_escape') + '\n' | ||
el = el.encode('utf-8') | ||||
else: | ||||
el = el[:-7].decode('string-escape') + '\n' | ||||
|
r25041 | if el == l or os.name == 'nt' and el[:-1] + b'\r\n' == l: | ||
|
r21315 | return True | ||
|
r25041 | if el.endswith(b" (re)\n"): | ||
|
r25388 | return TTest.rematch(el[:-6], l) or retry | ||
|
r25041 | if el.endswith(b" (glob)\n"): | ||
|
r23728 | # ignore '(glob)' added to l by 'replacements' | ||
|
r25041 | if l.endswith(b" (glob)\n"): | ||
l = l[:-8] + b"\n" | ||||
|
r31827 | return TTest.globmatch(el[:-8], l) or retry | ||
|
r25041 | if os.altsep and l.replace(b'\\', b'/') == el: | ||
return b'+glob' | ||||
|
r25388 | return retry | ||
|
r21315 | |||
|
r21379 | @staticmethod | ||
def parsehghaveoutput(lines): | ||||
'''Parse hghave log lines. | ||||
Return tuple of lists (missing, failed): | ||||
* the missing/unknown features | ||||
* the features for which existence check failed''' | ||||
missing = [] | ||||
failed = [] | ||||
for line in lines: | ||||
|
r21381 | if line.startswith(TTest.SKIPPED_PREFIX): | ||
|
r21379 | line = line.splitlines()[0] | ||
|
r28284 | missing.append(line[len(TTest.SKIPPED_PREFIX):].decode('utf-8')) | ||
|
r21381 | elif line.startswith(TTest.FAILED_PREFIX): | ||
|
r21379 | line = line.splitlines()[0] | ||
|
r28284 | failed.append(line[len(TTest.FAILED_PREFIX):].decode('utf-8')) | ||
|
r21379 | |||
return missing, failed | ||||
|
r21384 | @staticmethod | ||
def _escapef(m): | ||||
return TTest.ESCAPEMAP[m.group(0)] | ||||
@staticmethod | ||||
def _stringescape(s): | ||||
return TTest.ESCAPESUB(TTest._escapef, s) | ||||
|
r22104 | iolock = threading.RLock() | ||
|
r14000 | |||
|
r21429 | class TestResult(unittest._TextTestResult): | ||
"""Holds results when executing via unittest.""" | ||||
# Don't worry too much about accessing the non-public _TextTestResult. | ||||
# It is relatively common in Python testing tools. | ||||
|
r21460 | def __init__(self, options, *args, **kwargs): | ||
|
r21429 | super(TestResult, self).__init__(*args, **kwargs) | ||
|
r21460 | self._options = options | ||
|
r21430 | # unittest.TestResult didn't have skipped until 2.7. We need to | ||
# polyfill it. | ||||
self.skipped = [] | ||||
|
r21431 | # We have a custom "ignored" result that isn't present in any Python | ||
# unittest implementation. It is very similar to skipped. It may make | ||||
# sense to map it into skip some day. | ||||
self.ignored = [] | ||||
|
r21495 | self.times = [] | ||
|
r27637 | self._firststarttime = None | ||
|
r22044 | # Data stored for the benefit of generating xunit reports. | ||
self.successes = [] | ||||
self.faildata = {} | ||||
|
r21495 | |||
|
r33565 | if options.color == 'auto': | ||
|
r33568 | self.color = pygmentspresent and self.stream.isatty() | ||
|
r33565 | elif options.color == 'never': | ||
self.color = False | ||||
else: # 'always', for testing purposes | ||||
self.color = pygmentspresent | ||||
|
r33561 | |||
|
r21462 | def addFailure(self, test, reason): | ||
self.failures.append((test, reason)) | ||||
|
r21460 | |||
if self._options.first: | ||||
self.stop() | ||||
|
r21735 | else: | ||
|
r25046 | with iolock: | ||
|
r27393 | if reason == "timed out": | ||
self.stream.write('t') | ||||
else: | ||||
if not self._options.nodiff: | ||||
|
r34843 | self.stream.write('\n') | ||
# Exclude the '\n' from highlighting to lex correctly | ||||
formatted = 'ERROR: %s output changed\n' % test | ||||
|
r33931 | self.stream.write(highlightmsg(formatted, self.color)) | ||
|
r27393 | self.stream.write('!') | ||
|
r21754 | |||
|
r25046 | self.stream.flush() | ||
|
r21460 | |||
|
r22044 | def addSuccess(self, test): | ||
|
r25046 | with iolock: | ||
super(TestResult, self).addSuccess(test) | ||||
|
r22044 | self.successes.append(test) | ||
|
r21460 | |||
|
r22044 | def addError(self, test, err): | ||
super(TestResult, self).addError(test, err) | ||||
|
r21460 | if self._options.first: | ||
self.stop() | ||||
|
r21430 | # Polyfill. | ||
def addSkip(self, test, reason): | ||||
self.skipped.append((test, reason)) | ||||
|
r25046 | with iolock: | ||
if self.showAll: | ||||
self.stream.writeln('skipped %s' % reason) | ||||
else: | ||||
self.stream.write('s') | ||||
self.stream.flush() | ||||
|
r21430 | |||
|
r21431 | def addIgnore(self, test, reason): | ||
self.ignored.append((test, reason)) | ||||
|
r25046 | with iolock: | ||
if self.showAll: | ||||
self.stream.writeln('ignored %s' % reason) | ||||
|
r21997 | else: | ||
|
r25046 | if reason not in ('not retesting', "doesn't match keyword"): | ||
self.stream.write('i') | ||||
else: | ||||
self.testsRun += 1 | ||||
self.stream.flush() | ||||
|
r21431 | |||
|
r21523 | def addOutputMismatch(self, test, ret, got, expected): | ||
|
r21521 | """Record a mismatch in test output for a particular test.""" | ||
|
r22838 | if self.shouldStop: | ||
# don't print, some other test case already failed and | ||||
# printed, we're just stale and probably failed due to our | ||||
# temp dir getting cleaned up. | ||||
return | ||||
|
r21521 | |||
|
r21763 | accepted = False | ||
|
r22044 | lines = [] | ||
|
r21763 | |||
|
r25046 | with iolock: | ||
if self._options.nodiff: | ||||
pass | ||||
elif self._options.view: | ||||
|
r25056 | v = self._options.view | ||
|
r25159 | if PYTHON3: | ||
|
r25161 | v = _bytespath(v) | ||
|
r25056 | os.system(b"%s %s %s" % | ||
(v, test.refpath, test.errpath)) | ||||
|
r21521 | else: | ||
|
r25046 | servefail, lines = getdiff(expected, got, | ||
test.refpath, test.errpath) | ||||
if servefail: | ||||
|
r32943 | raise test.failureException( | ||
|
r25046 | 'server failed to start (HGPORT=%s)' % test._startport) | ||
else: | ||||
self.stream.write('\n') | ||||
for line in lines: | ||||
|
r33931 | line = highlightdiff(line, self.color) | ||
|
r25159 | if PYTHON3: | ||
|
r25053 | self.stream.flush() | ||
self.stream.buffer.write(line) | ||||
self.stream.buffer.flush() | ||||
else: | ||||
self.stream.write(line) | ||||
self.stream.flush() | ||||
|
r21521 | |||
|
r25046 | # handle interactive prompt without releasing iolock | ||
if self._options.interactive: | ||||
|
r32980 | if test.readrefout() != expected: | ||
self.stream.write( | ||||
'Reference output has changed (run again to prompt ' | ||||
'changes)') | ||||
else: | ||||
self.stream.write('Accept this change? [n] ') | ||||
answer = sys.stdin.readline().strip() | ||||
if answer.lower() in ('y', 'yes'): | ||||
|
r32982 | if test.path.endswith(b'.t'): | ||
|
r32980 | rename(test.errpath, test.path) | ||
else: | ||||
rename(test.errpath, '%s.out' % test.path) | ||||
accepted = True | ||||
|
r28127 | if not accepted: | ||
|
r25052 | self.faildata[test.name] = b''.join(lines) | ||
|
r21763 | |||
return accepted | ||||
|
r21523 | |||
|
r21495 | def startTest(self, test): | ||
super(TestResult, self).startTest(test) | ||||
|
r21977 | # os.times module computes the user time and system time spent by | ||
# child's processes along with real elapsed time taken by a process. | ||||
# This module has one limitation. It can only work for Linux user | ||||
# and not for Windows. | ||||
|
r24331 | test.started = os.times() | ||
|
r25097 | if self._firststarttime is None: # thread racy but irrelevant | ||
self._firststarttime = test.started[4] | ||||
|
r21495 | |||
def stopTest(self, test, interrupted=False): | ||||
super(TestResult, self).stopTest(test) | ||||
|
r24331 | test.stopped = os.times() | ||
|
r21977 | |||
|
r24331 | starttime = test.started | ||
endtime = test.stopped | ||||
|
r25097 | origin = self._firststarttime | ||
|
r24984 | self.times.append((test.name, | ||
endtime[2] - starttime[2], # user space CPU time | ||||
endtime[3] - starttime[3], # sys space CPU time | ||||
endtime[4] - starttime[4], # real time | ||||
|
r25097 | starttime[4] - origin, # start date in run context | ||
endtime[4] - origin, # end date in run context | ||||
|
r24984 | )) | ||
|
r21977 | |||
|
r21495 | if interrupted: | ||
|
r25046 | with iolock: | ||
self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % ( | ||||
test.name, self.times[-1][3])) | ||||
|
r21495 | |||
|
r21439 | class TestSuite(unittest.TestSuite): | ||
|
r23139 | """Custom unittest TestSuite that knows how to execute Mercurial tests.""" | ||
|
r21528 | |||
|
r21533 | def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None, | ||
|
r24329 | retest=False, keywords=None, loop=False, runs_per_test=1, | ||
|
r27396 | loadtest=None, showchannels=False, | ||
|
r21529 | *args, **kwargs): | ||
|
r21528 | """Create a new instance that can run tests with a configuration. | ||
|
r21439 | |||
|
r21533 | testdir specifies the directory where tests are executed from. This | ||
is typically the ``tests`` directory from Mercurial's source | ||||
repository. | ||||
|
r21528 | jobs specifies the number of jobs to run concurrently. Each test | ||
executes on its own thread. Tests actually spawn new processes, so | ||||
state mutation should not be an issue. | ||||
|
r21529 | |||
|
r27880 | If there is only one job, it will use the main thread. | ||
|
r21529 | whitelist and blacklist denote tests that have been whitelisted and | ||
blacklisted, respectively. These arguments don't belong in TestSuite. | ||||
Instead, whitelist and blacklist should be handled by the thing that | ||||
populates the TestSuite with tests. They are present to preserve | ||||
backwards compatible behavior which reports skipped tests as part | ||||
of the results. | ||||
|
r21530 | |||
retest denotes whether to retest failed tests. This arguably belongs | ||||
outside of TestSuite. | ||||
|
r21531 | |||
keywords denotes key words that will be used to filter which tests | ||||
to execute. This arguably belongs outside of TestSuite. | ||||
|
r21532 | |||
loop denotes whether to loop over tests forever. | ||||
|
r21528 | """ | ||
|
r21439 | super(TestSuite, self).__init__(*args, **kwargs) | ||
|
r21528 | self._jobs = jobs | ||
|
r21529 | self._whitelist = whitelist | ||
self._blacklist = blacklist | ||||
|
r21530 | self._retest = retest | ||
|
r21531 | self._keywords = keywords | ||
|
r21532 | self._loop = loop | ||
|
r24329 | self._runs_per_test = runs_per_test | ||
|
r24330 | self._loadtest = loadtest | ||
|
r27396 | self._showchannels = showchannels | ||
|
r21439 | |||
def run(self, result): | ||||
|
r21507 | # We have a number of filters that need to be applied. We do this | ||
# here instead of inside Test because it makes the running logic for | ||||
# Test simpler. | ||||
tests = [] | ||||
|
r24330 | num_tests = [0] | ||
|
r21507 | for test in self._tests: | ||
|
r24330 | def get(): | ||
num_tests[0] += 1 | ||||
if getattr(test, 'should_reload', False): | ||||
|
r32310 | return self._loadtest(test, num_tests[0]) | ||
|
r24330 | return test | ||
|
r21507 | if not os.path.exists(test.path): | ||
result.addSkip(test, "Doesn't exist") | ||||
continue | ||||
|
r34267 | if not (self._whitelist and test.bname in self._whitelist): | ||
|
r25055 | if self._blacklist and test.bname in self._blacklist: | ||
|
r21507 | result.addSkip(test, 'blacklisted') | ||
continue | ||||
|
r21530 | if self._retest and not os.path.exists(test.errpath): | ||
|
r21507 | result.addIgnore(test, 'not retesting') | ||
continue | ||||
|
r21531 | if self._keywords: | ||
|
r21916 | f = open(test.path, 'rb') | ||
|
r25048 | t = f.read().lower() + test.bname.lower() | ||
|
r21507 | f.close() | ||
ignored = False | ||||
|
r21531 | for k in self._keywords.lower().split(): | ||
|
r21507 | if k not in t: | ||
result.addIgnore(test, "doesn't match keyword") | ||||
ignored = True | ||||
break | ||||
if ignored: | ||||
continue | ||||
|
r24329 | for _ in xrange(self._runs_per_test): | ||
|
r24330 | tests.append(get()) | ||
|
r21496 | |||
|
r21520 | runtests = list(tests) | ||
|
r21496 | done = queue.Queue() | ||
running = 0 | ||||
|
r27396 | channels = [""] * self._jobs | ||
|
r21496 | def job(test, result): | ||
|
r27396 | for n, v in enumerate(channels): | ||
if not v: | ||||
channel = n | ||||
break | ||||
|
r32621 | else: | ||
raise ValueError('Could not find output channel') | ||||
|
r27396 | channels[channel] = "=" + test.name[5:].split(".")[0] | ||
|
r21496 | try: | ||
test(result) | ||||
done.put(None) | ||||
except KeyboardInterrupt: | ||||
|
r27933 | pass | ||
|
r21496 | except: # re-raises | ||
done.put(('!', test, 'run-test raised an error, see traceback')) | ||||
raise | ||||
|
r32622 | finally: | ||
try: | ||||
channels[channel] = '' | ||||
except IndexError: | ||||
pass | ||||
|
r27396 | |||
def stat(): | ||||
count = 0 | ||||
while channels: | ||||
d = '\n%03s ' % count | ||||
for n, v in enumerate(channels): | ||||
if v: | ||||
d += v[0] | ||||
channels[n] = v[1:] or '.' | ||||
else: | ||||
d += ' ' | ||||
d += ' ' | ||||
with iolock: | ||||
sys.stdout.write(d + ' ') | ||||
sys.stdout.flush() | ||||
for x in xrange(10): | ||||
if channels: | ||||
time.sleep(.1) | ||||
count += 1 | ||||
|
r21496 | |||
|
r24507 | stoppedearly = False | ||
|
r27396 | if self._showchannels: | ||
statthread = threading.Thread(target=stat, name="stat") | ||||
statthread.start() | ||||
|
r21496 | try: | ||
|
r27880 | while tests or running: | ||
if not done.empty() or running == self._jobs or not tests: | ||||
try: | ||||
done.get(True, 1) | ||||
running -= 1 | ||||
if result and result.shouldStop: | ||||
stoppedearly = True | ||||
break | ||||
except queue.Empty: | ||||
continue | ||||
if tests and not running == self._jobs: | ||||
test = tests.pop(0) | ||||
if self._loop: | ||||
if getattr(test, 'should_reload', False): | ||||
num_tests[0] += 1 | ||||
tests.append( | ||||
|
r32310 | self._loadtest(test, num_tests[0])) | ||
|
r27880 | else: | ||
tests.append(test) | ||||
if self._jobs == 1: | ||||
job(test, result) | ||||
else: | ||||
|
r27689 | t = threading.Thread(target=job, name=test.name, | ||
args=(test, result)) | ||||
t.start() | ||||
|
r27880 | running += 1 | ||
|
r24507 | |||
|
r27880 | # If we stop early we still need to wait on started tests to | ||
# finish. Otherwise, there is a race between the test completing | ||||
# and the test's cleanup code running. This could result in the | ||||
# test reporting incorrect. | ||||
if stoppedearly: | ||||
while running: | ||||
try: | ||||
done.get(True, 1) | ||||
running -= 1 | ||||
except queue.Empty: | ||||
continue | ||||
|
r21496 | except KeyboardInterrupt: | ||
|
r21520 | for test in runtests: | ||
test.abort() | ||||
|
r21439 | |||
|
r27396 | channels = [] | ||
|
r21439 | return result | ||
|
r27634 | # Save the most recent 5 wall-clock runtimes of each test to a | ||
# human-readable text file named .testtimes. Tests are sorted | ||||
# alphabetically, while times for each test are listed from oldest to | ||||
# newest. | ||||
|
r32717 | def loadtimes(outputdir): | ||
|
r27634 | times = [] | ||
try: | ||||
|
r32717 | with open(os.path.join(outputdir, b'.testtimes-')) as fp: | ||
|
r27634 | for line in fp: | ||
ts = line.split() | ||||
times.append((ts[0], [float(t) for t in ts[1:]])) | ||||
except IOError as err: | ||||
if err.errno != errno.ENOENT: | ||||
raise | ||||
return times | ||||
|
r32717 | def savetimes(outputdir, result): | ||
saved = dict(loadtimes(outputdir)) | ||||
|
r27634 | maxruns = 5 | ||
skipped = set([str(t[0]) for t in result.skipped]) | ||||
for tdata in result.times: | ||||
test, real = tdata[0], tdata[3] | ||||
if test not in skipped: | ||||
ts = saved.setdefault(test, []) | ||||
ts.append(real) | ||||
ts[:] = ts[-maxruns:] | ||||
|
r28284 | fd, tmpname = tempfile.mkstemp(prefix=b'.testtimes', | ||
|
r32717 | dir=outputdir, text=True) | ||
|
r27634 | with os.fdopen(fd, 'w') as fp: | ||
|
r28284 | for name, ts in sorted(saved.items()): | ||
|
r27634 | fp.write('%s %s\n' % (name, ' '.join(['%.3f' % (t,) for t in ts]))) | ||
|
r32717 | timepath = os.path.join(outputdir, b'.testtimes') | ||
|
r27634 | try: | ||
os.unlink(timepath) | ||||
except OSError: | ||||
pass | ||||
try: | ||||
os.rename(tmpname, timepath) | ||||
except OSError: | ||||
pass | ||||
|
r21429 | class TextTestRunner(unittest.TextTestRunner): | ||
"""Custom unittest test runner that uses appropriate settings.""" | ||||
|
r21459 | def __init__(self, runner, *args, **kwargs): | ||
super(TextTestRunner, self).__init__(*args, **kwargs) | ||||
self._runner = runner | ||||
|
r32704 | def listtests(self, test): | ||
result = TestResult(self._runner.options, self.stream, | ||||
self.descriptions, 0) | ||||
test = sorted(test, key=lambda t: t.name) | ||||
for t in test: | ||||
print(t.name) | ||||
result.addSuccess(t) | ||||
if self._runner.options.xunit: | ||||
with open(self._runner.options.xunit, "wb") as xuf: | ||||
self._writexunit(result, xuf) | ||||
if self._runner.options.json: | ||||
|
r32718 | jsonpath = os.path.join(self._runner._outputdir, b'report.json') | ||
|
r32704 | with open(jsonpath, 'w') as fp: | ||
self._writejson(result, fp) | ||||
return result | ||||
|
r21459 | def run(self, test): | ||
|
r21460 | result = TestResult(self._runner.options, self.stream, | ||
self.descriptions, self.verbosity) | ||||
|
r21459 | |||
test(result) | ||||
failed = len(result.failures) | ||||
skipped = len(result.skipped) | ||||
ignored = len(result.ignored) | ||||
|
r25046 | with iolock: | ||
self.stream.writeln('') | ||||
|
r21459 | |||
|
r25046 | if not self._runner.options.noskips: | ||
for test, msg in result.skipped: | ||||
|
r33930 | formatted = 'Skipped %s: %s\n' % (test.name, msg) | ||
|
r33931 | self.stream.write(highlightmsg(formatted, result.color)) | ||
|
r25046 | for test, msg in result.failures: | ||
|
r33930 | formatted = 'Failed %s: %s\n' % (test.name, msg) | ||
|
r33931 | self.stream.write(highlightmsg(formatted, result.color)) | ||
|
r25046 | for test, msg in result.errors: | ||
self.stream.writeln('Errored %s: %s' % (test.name, msg)) | ||||
|
r21459 | |||
|
r25046 | if self._runner.options.xunit: | ||
|
r32700 | with open(self._runner.options.xunit, "wb") as xuf: | ||
self._writexunit(result, xuf) | ||||
|
r22044 | |||
|
r25046 | if self._runner.options.json: | ||
|
r32718 | jsonpath = os.path.join(self._runner._outputdir, b'report.json') | ||
|
r27773 | with open(jsonpath, 'w') as fp: | ||
|
r32701 | self._writejson(result, fp) | ||
|
r22391 | |||
|
r25046 | self._runner._checkhglib('Tested') | ||
|
r21459 | |||
|
r32717 | savetimes(self._runner._outputdir, result) | ||
|
r28596 | |||
if failed and self._runner.options.known_good_rev: | ||||
|
r34803 | self._bisecttests(t for t, m in result.failures) | ||
|
r25046 | self.stream.writeln( | ||
|
r32942 | '# Ran %d tests, %d skipped, %d failed.' | ||
% (result.testsRun, skipped + ignored, failed)) | ||||
|
r25046 | if failed: | ||
self.stream.writeln('python hash seed: %s' % | ||||
os.environ['PYTHONHASHSEED']) | ||||
if self._runner.options.time: | ||||
self.printtimes(result.times) | ||||
|
r32907 | self.stream.flush() | ||
|
r22104 | |||
|
r21613 | return result | ||
|
r34803 | def _bisecttests(self, tests): | ||
bisectcmd = ['hg', 'bisect'] | ||||
bisectrepo = self._runner.options.bisect_repo | ||||
if bisectrepo: | ||||
bisectcmd.extend(['-R', os.path.abspath(bisectrepo)]) | ||||
|
r34804 | def pread(args): | ||
|
r34805 | env = os.environ.copy() | ||
env['HGPLAIN'] = '1' | ||||
|
r34803 | p = subprocess.Popen(args, stderr=subprocess.STDOUT, | ||
|
r34805 | stdout=subprocess.PIPE, env=env) | ||
|
r34804 | data = p.stdout.read() | ||
|
r34803 | p.wait() | ||
|
r34804 | return data | ||
|
r34803 | for test in tests: | ||
|
r34804 | pread(bisectcmd + ['--reset']), | ||
pread(bisectcmd + ['--bad', '.']) | ||||
pread(bisectcmd + ['--good', self._runner.options.known_good_rev]) | ||||
|
r34803 | # TODO: we probably need to forward more options | ||
# that alter hg's behavior inside the tests. | ||||
opts = '' | ||||
withhg = self._runner.options.with_hg | ||||
if withhg: | ||||
opts += ' --with-hg=%s ' % shellquote(_strpath(withhg)) | ||||
rtc = '%s %s %s %s' % (sys.executable, sys.argv[0], opts, | ||||
test) | ||||
|
r34804 | data = pread(bisectcmd + ['--command', rtc]) | ||
|
r34803 | m = re.search( | ||
(br'\nThe first (?P<goodbad>bad|good) revision ' | ||||
br'is:\nchangeset: +\d+:(?P<node>[a-f0-9]+)\n.*\n' | ||||
br'summary: +(?P<summary>[^\n]+)\n'), | ||||
data, (re.MULTILINE | re.DOTALL)) | ||||
if m is None: | ||||
self.stream.writeln( | ||||
'Failed to identify failure point for %s' % test) | ||||
continue | ||||
dat = m.groupdict() | ||||
verb = 'broken' if dat['goodbad'] == 'bad' else 'fixed' | ||||
self.stream.writeln( | ||||
'%s %s by %s (%s)' % ( | ||||
test, verb, dat['node'], dat['summary'])) | ||||
|
r21495 | def printtimes(self, times): | ||
|
r22104 | # iolock held by run | ||
|
r21494 | self.stream.writeln('# Producing time report') | ||
|
r21977 | times.sort(key=lambda t: (t[3])) | ||
|
r25098 | cols = '%7.3f %7.3f %7.3f %7.3f %7.3f %s' | ||
self.stream.writeln('%-7s %-7s %-7s %-7s %-7s %s' % | ||||
('start', 'end', 'cuser', 'csys', 'real', 'Test')) | ||||
|
r24982 | for tdata in times: | ||
test = tdata[0] | ||||
|
r25098 | cuser, csys, real, start, end = tdata[1:6] | ||
self.stream.writeln(cols % (start, end, cuser, csys, real, test)) | ||||
|
r21429 | |||
|
r32700 | @staticmethod | ||
def _writexunit(result, outf): | ||||
|
r32714 | # See http://llg.cubic.org/docs/junit/ for a reference. | ||
|
r32700 | timesd = dict((t[0], t[3]) for t in result.times) | ||
doc = minidom.Document() | ||||
s = doc.createElement('testsuite') | ||||
s.setAttribute('name', 'run-tests') | ||||
s.setAttribute('tests', str(result.testsRun)) | ||||
s.setAttribute('errors', "0") # TODO | ||||
s.setAttribute('failures', str(len(result.failures))) | ||||
s.setAttribute('skipped', str(len(result.skipped) + | ||||
len(result.ignored))) | ||||
doc.appendChild(s) | ||||
for tc in result.successes: | ||||
t = doc.createElement('testcase') | ||||
t.setAttribute('name', tc.name) | ||||
|
r32702 | tctime = timesd.get(tc.name) | ||
if tctime is not None: | ||||
t.setAttribute('time', '%.3f' % tctime) | ||||
|
r32700 | s.appendChild(t) | ||
for tc, err in sorted(result.faildata.items()): | ||||
t = doc.createElement('testcase') | ||||
t.setAttribute('name', tc) | ||||
|
r32702 | tctime = timesd.get(tc) | ||
if tctime is not None: | ||||
t.setAttribute('time', '%.3f' % tctime) | ||||
|
r32700 | # createCDATASection expects a unicode or it will | ||
# convert using default conversion rules, which will | ||||
# fail if string isn't ASCII. | ||||
err = cdatasafe(err).decode('utf-8', 'replace') | ||||
cd = doc.createCDATASection(err) | ||||
|
r32714 | # Use 'failure' here instead of 'error' to match errors = 0, | ||
# failures = len(result.failures) in the testsuite element. | ||||
failelem = doc.createElement('failure') | ||||
failelem.setAttribute('message', 'output changed') | ||||
failelem.setAttribute('type', 'output-mismatch') | ||||
failelem.appendChild(cd) | ||||
t.appendChild(failelem) | ||||
|
r32700 | s.appendChild(t) | ||
|
r32715 | for tc, message in result.skipped: | ||
# According to the schema, 'skipped' has no attributes. So store | ||||
# the skip message as a text node instead. | ||||
t = doc.createElement('testcase') | ||||
t.setAttribute('name', tc.name) | ||||
|
r34270 | binmessage = message.encode('utf-8') | ||
message = cdatasafe(binmessage).decode('utf-8', 'replace') | ||||
|
r32715 | cd = doc.createCDATASection(message) | ||
skipelem = doc.createElement('skipped') | ||||
skipelem.appendChild(cd) | ||||
t.appendChild(skipelem) | ||||
s.appendChild(t) | ||||
|
r32700 | outf.write(doc.toprettyxml(indent=' ', encoding='utf-8')) | ||
|
r32701 | @staticmethod | ||
def _writejson(result, outf): | ||||
timesd = {} | ||||
for tdata in result.times: | ||||
test = tdata[0] | ||||
timesd[test] = tdata[1:] | ||||
outcome = {} | ||||
groups = [('success', ((tc, None) | ||||
for tc in result.successes)), | ||||
('failure', result.failures), | ||||
('skip', result.skipped)] | ||||
for res, testcases in groups: | ||||
for tc, __ in testcases: | ||||
if tc.name in timesd: | ||||
diff = result.faildata.get(tc.name, b'') | ||||
|
r32853 | try: | ||
diff = diff.decode('unicode_escape') | ||||
except UnicodeDecodeError as e: | ||||
diff = '%r decoding diff, sorry' % e | ||||
|
r32701 | tres = {'result': res, | ||
'time': ('%0.3f' % timesd[tc.name][2]), | ||||
'cuser': ('%0.3f' % timesd[tc.name][0]), | ||||
'csys': ('%0.3f' % timesd[tc.name][1]), | ||||
'start': ('%0.3f' % timesd[tc.name][3]), | ||||
'end': ('%0.3f' % timesd[tc.name][4]), | ||||
|
r32853 | 'diff': diff, | ||
|
r32701 | } | ||
else: | ||||
# blacklisted test | ||||
tres = {'result': res} | ||||
outcome[tc.name] = tres | ||||
jsonout = json.dumps(outcome, sort_keys=True, indent=4, | ||||
separators=(',', ': ')) | ||||
outf.writelines(("testreport =", jsonout)) | ||||
|
r21340 | class TestRunner(object): | ||
"""Holds context for executing tests. | ||||
Tests rely on a lot of state. This object holds it for them. | ||||
""" | ||||
|
r21357 | |||
|
r21536 | # Programs required to run tests. | ||
|
r21365 | REQUIREDTOOLS = [ | ||
|
r25041 | b'diff', | ||
b'grep', | ||||
b'unzip', | ||||
b'gunzip', | ||||
b'bunzip2', | ||||
b'sed', | ||||
|
r21365 | ] | ||
|
r21536 | # Maps file extensions to test class. | ||
|
r21357 | TESTTYPES = [ | ||
|
r25041 | (b'.py', PythonTest), | ||
(b'.t', TTest), | ||||
|
r21357 | ] | ||
|
r21341 | def __init__(self): | ||
|
r21348 | self.options = None | ||
|
r24506 | self._hgroot = None | ||
|
r21534 | self._testdir = None | ||
|
r32716 | self._outputdir = None | ||
|
r21534 | self._hgtmp = None | ||
self._installdir = None | ||||
self._bindir = None | ||||
self._tmpbinddir = None | ||||
self._pythondir = None | ||||
self._coveragefile = None | ||||
|
r21352 | self._createdfiles = [] | ||
|
r28099 | self._hgcommand = None | ||
|
r21385 | self._hgpath = None | ||
|
r24967 | self._portoffset = 0 | ||
self._ports = {} | ||||
|
r21340 | |||
|
r21376 | def run(self, args, parser=None): | ||
|
r21366 | """Run the test suite.""" | ||
|
r25031 | oldmask = os.umask(0o22) | ||
|
r21375 | try: | ||
|
r21376 | parser = parser or getparser() | ||
|
r35188 | options = parseargs(args, parser) | ||
tests = [_bytespath(a) for a in options.tests] | ||||
|
r34264 | if options.test_list is not None: | ||
for listfile in options.test_list: | ||||
with open(listfile, 'rb') as f: | ||||
|
r35188 | tests.extend(t for t in f.read().splitlines() if t) | ||
|
r21376 | self.options = options | ||
|
r21375 | self._checktools() | ||
|
r35188 | testdescs = self.findtests(tests) | ||
|
r25107 | if options.profile_runner: | ||
import statprof | ||||
statprof.start() | ||||
|
r32311 | result = self._run(testdescs) | ||
|
r25107 | if options.profile_runner: | ||
statprof.stop() | ||||
statprof.display() | ||||
return result | ||||
|
r21375 | finally: | ||
os.umask(oldmask) | ||||
|
r21366 | |||
|
r32311 | def _run(self, testdescs): | ||
|
r21372 | if self.options.random: | ||
|
r32311 | random.shuffle(testdescs) | ||
|
r21372 | else: | ||
# keywords for slow tests | ||||
|
r25067 | slow = {b'svn': 10, | ||
|
r27394 | b'cvs': 10, | ||
b'hghave': 10, | ||||
b'largefiles-update': 10, | ||||
b'run-tests': 10, | ||||
b'corruption': 10, | ||||
b'race': 10, | ||||
b'i18n': 10, | ||||
b'check': 100, | ||||
b'gendoc': 100, | ||||
|
r27101 | b'contrib-perf': 200, | ||
|
r25067 | } | ||
|
r27635 | perf = {} | ||
|
r21372 | def sortkey(f): | ||
# run largest tests first, as they tend to take the longest | ||||
|
r32310 | f = f['path'] | ||
|
r21372 | try: | ||
|
r27635 | return perf[f] | ||
except KeyError: | ||||
try: | ||||
val = -os.stat(f).st_size | ||||
except OSError as e: | ||||
if e.errno != errno.ENOENT: | ||||
raise | ||||
perf[f] = -1e9 # file does not exist, tell early | ||||
return -1e9 | ||||
for kw, mul in slow.items(): | ||||
if kw in f: | ||||
val *= mul | ||||
|
r28096 | if f.endswith(b'.py'): | ||
|
r27636 | val /= 10.0 | ||
perf[f] = val / 1000.0 | ||||
|
r27635 | return perf[f] | ||
|
r32311 | testdescs.sort(key=sortkey) | ||
|
r21372 | |||
|
r25041 | self._testdir = osenvironb[b'TESTDIR'] = getattr( | ||
os, 'getcwdb', os.getcwd)() | ||||
|
r34963 | # assume all tests in same folder for now | ||
if testdescs: | ||||
pathname = os.path.dirname(testdescs[0]['path']) | ||||
|
r35065 | if pathname: | ||
osenvironb[b'TESTDIR'] = os.path.join(osenvironb[b'TESTDIR'], | ||||
pathname) | ||||
|
r32716 | if self.options.outputdir: | ||
self._outputdir = canonpath(_bytespath(self.options.outputdir)) | ||||
else: | ||||
self._outputdir = self._testdir | ||||
|
r35096 | if testdescs and pathname: | ||
self._outputdir = os.path.join(self._outputdir, pathname) | ||||
|
r21371 | |||
|
r21370 | if 'PYTHONHASHSEED' not in os.environ: | ||
# use a random python hash seed all the time | ||||
# we do the randomness ourself to know what seed is used | ||||
os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32)) | ||||
|
r21369 | if self.options.tmpdir: | ||
self.options.keep_tmpdir = True | ||||
|
r25161 | tmpdir = _bytespath(self.options.tmpdir) | ||
|
r21369 | if os.path.exists(tmpdir): | ||
# Meaning of tmpdir has changed since 1.3: we used to create | ||||
# HGTMP inside tmpdir; now HGTMP is tmpdir. So fail if | ||||
# tmpdir already exists. | ||||
|
r25031 | print("error: temp dir %r already exists" % tmpdir) | ||
|
r21369 | return 1 | ||
# Automatically removing tmpdir sounds convenient, but could | ||||
# really annoy anyone in the habit of using "--tmpdir=/tmp" | ||||
# or "--tmpdir=$HOME". | ||||
#vlog("# Removing temp dir", tmpdir) | ||||
#shutil.rmtree(tmpdir) | ||||
os.makedirs(tmpdir) | ||||
else: | ||||
d = None | ||||
if os.name == 'nt': | ||||
# without this, we get the default temp dir location, but | ||||
# in all lowercase, which causes troubles with paths (issue3490) | ||||
|
r25041 | d = osenvironb.get(b'TMP', None) | ||
|
r25262 | tmpdir = tempfile.mkdtemp(b'', b'hgtests.', d) | ||
|
r25041 | |||
self._hgtmp = osenvironb[b'HGTMP'] = ( | ||||
os.path.realpath(tmpdir)) | ||||
|
r21369 | |||
|
r21368 | if self.options.with_hg: | ||
|
r21534 | self._installdir = None | ||
|
r25042 | whg = self.options.with_hg | ||
self._bindir = os.path.dirname(os.path.realpath(whg)) | ||||
assert isinstance(self._bindir, bytes) | ||||
|
r28099 | self._hgcommand = os.path.basename(whg) | ||
|
r25041 | self._tmpbindir = os.path.join(self._hgtmp, b'install', b'bin') | ||
|
r21534 | os.makedirs(self._tmpbindir) | ||
|
r21368 | |||
# This looks redundant with how Python initializes sys.path from | ||||
# the location of the script being executed. Needed because the | ||||
# "hg" specified by --with-hg is not the only Python script | ||||
# executed in the test suite that needs to import 'mercurial' | ||||
# ... which means it's not really redundant at all. | ||||
|
r21534 | self._pythondir = self._bindir | ||
|
r21368 | else: | ||
|
r25041 | self._installdir = os.path.join(self._hgtmp, b"install") | ||
|
r28098 | self._bindir = os.path.join(self._installdir, b"bin") | ||
|
r28099 | self._hgcommand = b'hg' | ||
|
r21534 | self._tmpbindir = self._bindir | ||
|
r25041 | self._pythondir = os.path.join(self._installdir, b"lib", b"python") | ||
|
r21368 | |||
|
r28620 | # set CHGHG, then replace "hg" command by "chg" | ||
|
r28142 | chgbindir = self._bindir | ||
|
r28143 | if self.options.chg or self.options.with_chg: | ||
|
r28142 | osenvironb[b'CHGHG'] = os.path.join(self._bindir, self._hgcommand) | ||
|
r28880 | else: | ||
osenvironb.pop(b'CHGHG', None) # drop flag for hghave | ||||
|
r28143 | if self.options.chg: | ||
self._hgcommand = b'chg' | ||||
elif self.options.with_chg: | ||||
|
r28142 | chgbindir = os.path.dirname(os.path.realpath(self.options.with_chg)) | ||
self._hgcommand = os.path.basename(self.options.with_chg) | ||||
|
r25041 | osenvironb[b"BINDIR"] = self._bindir | ||
|
r25058 | osenvironb[b"PYTHON"] = PYTHON | ||
|
r21368 | |||
|
r28582 | if self.options.with_python3: | ||
osenvironb[b'PYTHON3'] = self.options.with_python3 | ||||
|
r25161 | fileb = _bytespath(__file__) | ||
|
r25041 | runtestdir = os.path.abspath(os.path.dirname(fileb)) | ||
|
r25729 | osenvironb[b'RUNTESTDIR'] = runtestdir | ||
|
r25159 | if PYTHON3: | ||
|
r25161 | sepb = _bytespath(os.pathsep) | ||
|
r25041 | else: | ||
sepb = os.pathsep | ||||
path = [self._bindir, runtestdir] + osenvironb[b"PATH"].split(sepb) | ||||
|
r24742 | if os.path.islink(__file__): | ||
# test helper will likely be at the end of the symlink | ||||
|
r25041 | realfile = os.path.realpath(fileb) | ||
|
r24742 | realdir = os.path.abspath(os.path.dirname(realfile)) | ||
path.insert(2, realdir) | ||||
|
r28142 | if chgbindir != self._bindir: | ||
path.insert(1, chgbindir) | ||||
|
r25730 | if self._testdir != runtestdir: | ||
path = [self._testdir] + path | ||||
|
r21534 | if self._tmpbindir != self._bindir: | ||
path = [self._tmpbindir] + path | ||||
|
r25041 | osenvironb[b"PATH"] = sepb.join(path) | ||
|
r21368 | |||
|
r21367 | # Include TESTDIR in PYTHONPATH so that out-of-tree extensions | ||
# can run .../tests/run-tests.py test-foo where test-foo | ||||
# adds an extension to HGRC. Also include run-test.py directory to | ||||
# import modules like heredoctest. | ||||
|
r23859 | pypath = [self._pythondir, self._testdir, runtestdir] | ||
|
r21367 | # We have to augment PYTHONPATH, rather than simply replacing | ||
# it, in case external libraries are only available via current | ||||
# PYTHONPATH. (In particular, the Subversion bindings on OS X | ||||
# are in /opt/subversion.) | ||||
|
r25041 | oldpypath = osenvironb.get(IMPL_PATH) | ||
|
r21367 | if oldpypath: | ||
pypath.append(oldpypath) | ||||
|
r25041 | osenvironb[IMPL_PATH] = sepb.join(pypath) | ||
|
r21367 | |||
|
r23935 | if self.options.pure: | ||
os.environ["HGTEST_RUN_TESTS_PURE"] = "--pure" | ||||
|
r28905 | os.environ["HGMODULEPOLICY"] = "py" | ||
|
r23935 | |||
|
r26109 | if self.options.allow_slow_tests: | ||
os.environ["HGTEST_SLOW"] = "slow" | ||||
elif 'HGTEST_SLOW' in os.environ: | ||||
del os.environ['HGTEST_SLOW'] | ||||
|
r25041 | self._coveragefile = os.path.join(self._testdir, b'.coverage') | ||
|
r21367 | |||
|
r21534 | vlog("# Using TESTDIR", self._testdir) | ||
|
r25729 | vlog("# Using RUNTESTDIR", osenvironb[b'RUNTESTDIR']) | ||
|
r21534 | vlog("# Using HGTMP", self._hgtmp) | ||
|
r21366 | vlog("# Using PATH", os.environ["PATH"]) | ||
|
r25041 | vlog("# Using", IMPL_PATH, osenvironb[IMPL_PATH]) | ||
|
r32716 | vlog("# Writing to directory", self._outputdir) | ||
|
r21366 | |||
try: | ||||
|
r32311 | return self._runtests(testdescs) or 0 | ||
|
r21366 | finally: | ||
time.sleep(.1) | ||||
self._cleanup() | ||||
|
r21363 | def findtests(self, args): | ||
"""Finds possible test files from arguments. | ||||
If you wish to inject custom tests into the test harness, this would | ||||
be a good function to monkeypatch or override in a derived class. | ||||
""" | ||||
if not args: | ||||
if self.options.changed: | ||||
proc = Popen4('hg st --rev "%s" -man0 .' % | ||||
self.options.changed, None, 0) | ||||
stdout, stderr = proc.communicate() | ||||
|
r25041 | args = stdout.strip(b'\0').split(b'\0') | ||
|
r21363 | else: | ||
|
r25041 | args = os.listdir(b'.') | ||
|
r21363 | |||
|
r34970 | expanded_args = [] | ||
for arg in args: | ||||
if os.path.isdir(arg): | ||||
if not arg.endswith(b'/'): | ||||
arg += b'/' | ||||
expanded_args.extend([arg + a for a in os.listdir(arg)]) | ||||
else: | ||||
expanded_args.append(arg) | ||||
args = expanded_args | ||||
|
r32317 | tests = [] | ||
for t in args: | ||||
if not (os.path.basename(t).startswith(b'test-') | ||||
and (t.endswith(b'.py') or t.endswith(b'.t'))): | ||||
continue | ||||
if t.endswith(b'.t'): | ||||
# .t file may contain multiple test cases | ||||
cases = sorted(parsettestcases(t)) | ||||
if cases: | ||||
tests += [{'path': t, 'case': c} for c in sorted(cases)] | ||||
else: | ||||
tests.append({'path': t}) | ||||
else: | ||||
tests.append({'path': t}) | ||||
return tests | ||||
|
r21363 | |||
|
r32311 | def _runtests(self, testdescs): | ||
|
r32310 | def _reloadtest(test, i): | ||
# convert a test back to its description dict | ||||
desc = {'path': test.path} | ||||
|
r32317 | case = getattr(test, '_case', None) | ||
if case: | ||||
desc['case'] = case | ||||
|
r32310 | return self._gettest(desc, i) | ||
|
r21360 | try: | ||
if self.options.restart: | ||||
|
r32311 | orig = list(testdescs) | ||
while testdescs: | ||||
|
r32317 | desc = testdescs[0] | ||
|
r32720 | # desc['path'] is a relative path | ||
|
r32317 | if 'case' in desc: | ||
errpath = b'%s.%s.err' % (desc['path'], desc['case']) | ||||
else: | ||||
errpath = b'%s.err' % desc['path'] | ||||
|
r32720 | errpath = os.path.join(self._outputdir, errpath) | ||
|
r32317 | if os.path.exists(errpath): | ||
|
r21360 | break | ||
|
r32311 | testdescs.pop(0) | ||
if not testdescs: | ||||
|
r25031 | print("running all tests") | ||
|
r32311 | testdescs = orig | ||
|
r21360 | |||
|
r32311 | tests = [self._gettest(d, i) for i, d in enumerate(testdescs)] | ||
|
r21437 | |||
|
r21458 | failed = False | ||
|
r25050 | kws = self.options.keywords | ||
|
r25159 | if kws is not None and PYTHON3: | ||
|
r25050 | kws = kws.encode('utf-8') | ||
|
r21458 | |||
|
r21534 | suite = TestSuite(self._testdir, | ||
|
r21533 | jobs=self.options.jobs, | ||
|
r21529 | whitelist=self.options.whitelisted, | ||
blacklist=self.options.blacklist, | ||||
|
r21530 | retest=self.options.retest, | ||
|
r25050 | keywords=kws, | ||
|
r21532 | loop=self.options.loop, | ||
|
r24329 | runs_per_test=self.options.runs_per_test, | ||
|
r27396 | showchannels=self.options.showchannels, | ||
|
r32310 | tests=tests, loadtest=_reloadtest) | ||
|
r21464 | verbosity = 1 | ||
if self.options.verbose: | ||||
verbosity = 2 | ||||
runner = TextTestRunner(self, verbosity=verbosity) | ||||
|
r32703 | |||
|
r32704 | if self.options.list_tests: | ||
result = runner.listtests(suite) | ||||
|
r32703 | else: | ||
|
r32704 | if self._installdir: | ||
self._installhg() | ||||
self._checkhglib("Testing") | ||||
else: | ||||
self._usecorrectpython() | ||||
if self.options.chg: | ||||
assert self._installdir | ||||
self._installchg() | ||||
|
r32703 | |||
|
r32704 | result = runner.run(suite) | ||
|
r21613 | |||
if result.failures: | ||||
failed = True | ||||
|
r21360 | |||
if self.options.anycoverage: | ||||
|
r21378 | self._outputcoverage() | ||
|
r21360 | except KeyboardInterrupt: | ||
failed = True | ||||
|
r25031 | print("\ninterrupted!") | ||
|
r21360 | |||
if failed: | ||||
return 1 | ||||
|
r24967 | def _getport(self, count): | ||
port = self._ports.get(count) # do we have a cached entry? | ||||
if port is None: | ||||
portneeded = 3 | ||||
# above 100 tries we just give up and let test reports failure | ||||
for tries in xrange(100): | ||||
allfree = True | ||||
|
r27602 | port = self.options.port + self._portoffset | ||
|
r24967 | for idx in xrange(portneeded): | ||
if not checkportisavailable(port + idx): | ||||
allfree = False | ||||
break | ||||
self._portoffset += portneeded | ||||
if allfree: | ||||
break | ||||
self._ports[count] = port | ||||
return port | ||||
|
r32311 | def _gettest(self, testdesc, count): | ||
|
r21357 | """Obtain a Test by looking at its filename. | ||
Returns a Test instance. The Test may not be runnable if it doesn't | ||||
map to a known type. | ||||
""" | ||||
|
r32311 | path = testdesc['path'] | ||
|
r32310 | lctest = path.lower() | ||
|
r21357 | testcls = Test | ||
|
r21501 | for ext, cls in self.TESTTYPES: | ||
|
r21357 | if lctest.endswith(ext): | ||
testcls = cls | ||||
break | ||||
|
r32310 | refpath = os.path.join(self._testdir, path) | ||
|
r25041 | tmpdir = os.path.join(self._hgtmp, b'child%d' % count) | ||
|
r21504 | |||
|
r32317 | # extra keyword parameters. 'case' is used by .t tests | ||
kwds = dict((k, testdesc[k]) for k in ['case'] if k in testdesc) | ||||
|
r32716 | t = testcls(refpath, self._outputdir, tmpdir, | ||
|
r24330 | keeptmpdir=self.options.keep_tmpdir, | ||
debug=self.options.debug, | ||||
timeout=self.options.timeout, | ||||
|
r24967 | startport=self._getport(count), | ||
|
r24330 | extraconfigopts=self.options.extra_config_opt, | ||
py3kwarnings=self.options.py3k_warnings, | ||||
|
r28099 | shell=self.options.shell, | ||
|
r28620 | hgcommand=self._hgcommand, | ||
|
r30986 | usechg=bool(self.options.with_chg or self.options.chg), | ||
|
r32317 | useipv6=useipv6, **kwds) | ||
|
r24330 | t.should_reload = True | ||
return t | ||||
|
r21357 | |||
|
r21366 | def _cleanup(self): | ||
|
r21350 | """Clean up state from this test invocation.""" | ||
if self.options.keep_tmpdir: | ||||
return | ||||
|
r21534 | vlog("# Cleaning up HGTMP", self._hgtmp) | ||
shutil.rmtree(self._hgtmp, True) | ||||
|
r21352 | for f in self._createdfiles: | ||
|
r21350 | try: | ||
os.remove(f) | ||||
except OSError: | ||||
pass | ||||
|
r21378 | def _usecorrectpython(self): | ||
|
r21536 | """Configure the environment to use the appropriate Python in tests.""" | ||
# Tests must use the same interpreter as us or bad things will happen. | ||||
|
r25041 | pyexename = sys.platform == 'win32' and b'python.exe' or b'python' | ||
|
r21351 | if getattr(os, 'symlink', None): | ||
vlog("# Making python executable in test path a symlink to '%s'" % | ||||
sys.executable) | ||||
|
r21534 | mypython = os.path.join(self._tmpbindir, pyexename) | ||
|
r21351 | try: | ||
if os.readlink(mypython) == sys.executable: | ||||
return | ||||
os.unlink(mypython) | ||||
|
r25031 | except OSError as err: | ||
|
r21351 | if err.errno != errno.ENOENT: | ||
raise | ||||
|
r21365 | if self._findprogram(pyexename) != sys.executable: | ||
|
r21351 | try: | ||
os.symlink(sys.executable, mypython) | ||||
|
r21352 | self._createdfiles.append(mypython) | ||
|
r25031 | except OSError as err: | ||
|
r21351 | # child processes may race, which is harmless | ||
if err.errno != errno.EEXIST: | ||||
raise | ||||
else: | ||||
exedir, exename = os.path.split(sys.executable) | ||||
vlog("# Modifying search path to find %s as %s in '%s'" % | ||||
(exename, pyexename, exedir)) | ||||
path = os.environ['PATH'].split(os.pathsep) | ||||
while exedir in path: | ||||
path.remove(exedir) | ||||
os.environ['PATH'] = os.pathsep.join([exedir] + path) | ||||
|
r21365 | if not self._findprogram(pyexename): | ||
|
r25031 | print("WARNING: Cannot find %s in search path" % pyexename) | ||
|
r21351 | |||
|
r21378 | def _installhg(self): | ||
|
r21536 | """Install hg into the test environment. | ||
This will also configure hg with the appropriate testing settings. | ||||
""" | ||||
|
r21353 | vlog("# Performing temporary installation of HG") | ||
|
r28829 | installerrs = os.path.join(self._hgtmp, b"install.err") | ||
|
r21353 | compiler = '' | ||
if self.options.compiler: | ||||
compiler = '--compiler ' + self.options.compiler | ||||
|
r24306 | if self.options.pure: | ||
|
r25044 | pure = b"--pure" | ||
|
r24306 | else: | ||
|
r25044 | pure = b"" | ||
|
r21353 | |||
# Run installer in hg root | ||||
script = os.path.realpath(sys.argv[0]) | ||||
|
r25044 | exe = sys.executable | ||
|
r25159 | if PYTHON3: | ||
|
r25161 | compiler = _bytespath(compiler) | ||
script = _bytespath(script) | ||||
exe = _bytespath(exe) | ||||
|
r21353 | hgroot = os.path.dirname(os.path.dirname(script)) | ||
|
r24506 | self._hgroot = hgroot | ||
|
r21353 | os.chdir(hgroot) | ||
|
r25044 | nohome = b'--home=""' | ||
|
r21353 | if os.name == 'nt': | ||
# The --home="" trick works only on OS where os.sep == '/' | ||||
# because of a distutils convert_path() fast-path. Avoid it at | ||||
# least on Windows for now, deal with .pydistutils.cfg bugs | ||||
# when they happen. | ||||
|
r25044 | nohome = b'' | ||
|
r28397 | cmd = (b'%(exe)s setup.py %(pure)s clean --all' | ||
|
r25044 | b' build %(compiler)s --build-base="%(base)s"' | ||
b' install --force --prefix="%(prefix)s"' | ||||
b' --install-lib="%(libdir)s"' | ||||
b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1' | ||||
|
r28397 | % {b'exe': exe, b'pure': pure, | ||
|
r25044 | b'compiler': compiler, | ||
b'base': os.path.join(self._hgtmp, b"build"), | ||||
b'prefix': self._installdir, b'libdir': self._pythondir, | ||||
b'bindir': self._bindir, | ||||
b'nohome': nohome, b'logfile': installerrs}) | ||||
|
r24075 | |||
# setuptools requires install directories to exist. | ||||
def makedirs(p): | ||||
try: | ||||
os.makedirs(p) | ||||
|
r25031 | except OSError as e: | ||
|
r24075 | if e.errno != errno.EEXIST: | ||
raise | ||||
makedirs(self._pythondir) | ||||
makedirs(self._bindir) | ||||
|
r21353 | vlog("# Running", cmd) | ||
if os.system(cmd) == 0: | ||||
if not self.options.verbose: | ||||
|
r26087 | try: | ||
os.remove(installerrs) | ||||
except OSError as e: | ||||
if e.errno != errno.ENOENT: | ||||
raise | ||||
|
r21353 | else: | ||
|
r21916 | f = open(installerrs, 'rb') | ||
|
r21353 | for line in f: | ||
|
r25159 | if PYTHON3: | ||
|
r25040 | sys.stdout.buffer.write(line) | ||
else: | ||||
sys.stdout.write(line) | ||||
|
r21353 | f.close() | ||
sys.exit(1) | ||||
|
r21534 | os.chdir(self._testdir) | ||
|
r21353 | |||
|
r21378 | self._usecorrectpython() | ||
|
r21353 | |||
if self.options.py3k_warnings and not self.options.anycoverage: | ||||
vlog("# Updating hg command to enable Py3k Warnings switch") | ||||
|
r21916 | f = open(os.path.join(self._bindir, 'hg'), 'rb') | ||
|
r21353 | lines = [line.rstrip() for line in f] | ||
lines[0] += ' -3' | ||||
f.close() | ||||
|
r21916 | f = open(os.path.join(self._bindir, 'hg'), 'wb') | ||
|
r21353 | for line in lines: | ||
f.write(line + '\n') | ||||
f.close() | ||||
|
r25044 | hgbat = os.path.join(self._bindir, b'hg.bat') | ||
|
r21353 | if os.path.isfile(hgbat): | ||
# hg.bat expects to be put in bin/scripts while run-tests.py | ||||
# installation layout put it in bin/ directly. Fix it | ||||
f = open(hgbat, 'rb') | ||||
data = f.read() | ||||
f.close() | ||||
|
r25044 | if b'"%~dp0..\python" "%~dp0hg" %*' in data: | ||
data = data.replace(b'"%~dp0..\python" "%~dp0hg" %*', | ||||
b'"%~dp0python" "%~dp0hg" %*') | ||||
|
r21353 | f = open(hgbat, 'wb') | ||
f.write(data) | ||||
f.close() | ||||
else: | ||||
|
r25031 | print('WARNING: cannot fix hg.bat reference to python.exe') | ||
|
r21353 | |||
if self.options.anycoverage: | ||||
|
r21534 | custom = os.path.join(self._testdir, 'sitecustomize.py') | ||
target = os.path.join(self._pythondir, 'sitecustomize.py') | ||||
|
r21353 | vlog('# Installing coverage trigger to %s' % target) | ||
shutil.copyfile(custom, target) | ||||
|
r21534 | rc = os.path.join(self._testdir, '.coveragerc') | ||
|
r21353 | vlog('# Installing coverage rc to %s' % rc) | ||
os.environ['COVERAGE_PROCESS_START'] = rc | ||||
|
r24505 | covdir = os.path.join(self._installdir, '..', 'coverage') | ||
try: | ||||
os.mkdir(covdir) | ||||
|
r25031 | except OSError as e: | ||
|
r24505 | if e.errno != errno.EEXIST: | ||
raise | ||||
os.environ['COVERAGE_DIR'] = covdir | ||||
|
r21353 | |||
|
r21378 | def _checkhglib(self, verb): | ||
|
r21354 | """Ensure that the 'mercurial' package imported by python is | ||
the one we expect it to be. If not, print a warning to stderr.""" | ||||
|
r21733 | if ((self._bindir == self._pythondir) and | ||
(self._bindir != self._tmpbindir)): | ||||
|
r23139 | # The pythondir has been inferred from --with-hg flag. | ||
# We cannot expect anything sensible here. | ||||
|
r21733 | return | ||
|
r25044 | expecthg = os.path.join(self._pythondir, b'mercurial') | ||
|
r21385 | actualhg = self._gethgpath() | ||
|
r21354 | if os.path.abspath(actualhg) != os.path.abspath(expecthg): | ||
sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n' | ||||
' (expected %s)\n' | ||||
% (verb, actualhg, expecthg)) | ||||
|
r21385 | def _gethgpath(self): | ||
"""Return the path to the mercurial package that is actually found by | ||||
the current Python interpreter.""" | ||||
if self._hgpath is not None: | ||||
return self._hgpath | ||||
|
r25058 | cmd = b'%s -c "import mercurial; print (mercurial.__path__[0])"' | ||
cmd = cmd % PYTHON | ||||
|
r25159 | if PYTHON3: | ||
|
r25162 | cmd = _strpath(cmd) | ||
|
r25058 | pipe = os.popen(cmd) | ||
|
r21385 | try: | ||
|
r25161 | self._hgpath = _bytespath(pipe.read().strip()) | ||
|
r21385 | finally: | ||
pipe.close() | ||||
return self._hgpath | ||||
|
r21354 | |||
|
r28143 | def _installchg(self): | ||
"""Install chg into the test environment""" | ||||
vlog('# Performing temporary installation of CHG') | ||||
assert os.path.dirname(self._bindir) == self._installdir | ||||
assert self._hgroot, 'must be called after _installhg()' | ||||
cmd = (b'"%(make)s" clean install PREFIX="%(prefix)s"' | ||||
% {b'make': 'make', # TODO: switch by option or environment? | ||||
b'prefix': self._installdir}) | ||||
cwd = os.path.join(self._hgroot, b'contrib', b'chg') | ||||
vlog("# Running", cmd) | ||||
proc = subprocess.Popen(cmd, shell=True, cwd=cwd, | ||||
stdin=subprocess.PIPE, stdout=subprocess.PIPE, | ||||
stderr=subprocess.STDOUT) | ||||
out, _err = proc.communicate() | ||||
if proc.returncode != 0: | ||||
if PYTHON3: | ||||
sys.stdout.buffer.write(out) | ||||
else: | ||||
sys.stdout.write(out) | ||||
sys.exit(1) | ||||
|
r21378 | def _outputcoverage(self): | ||
|
r21536 | """Produce code coverage output.""" | ||
|
r29485 | import coverage | ||
coverage = coverage.coverage | ||||
|
r21356 | |||
|
r24504 | vlog('# Producing coverage report') | ||
# chdir is the easiest way to get short, relative paths in the | ||||
# output. | ||||
|
r24506 | os.chdir(self._hgroot) | ||
|
r24505 | covdir = os.path.join(self._installdir, '..', 'coverage') | ||
cov = coverage(data_file=os.path.join(covdir, 'cov')) | ||||
|
r24506 | |||
# Map install directory paths back to source directory. | ||||
cov.config.paths['srcdir'] = ['.', self._pythondir] | ||||
|
r24505 | cov.combine() | ||
|
r21356 | |||
|
r24504 | omit = [os.path.join(x, '*') for x in [self._bindir, self._testdir]] | ||
cov.report(ignore_errors=True, omit=omit) | ||||
|
r21356 | if self.options.htmlcov: | ||
|
r32719 | htmldir = os.path.join(self._outputdir, 'htmlcov') | ||
|
r24504 | cov.html_report(directory=htmldir, omit=omit) | ||
|
r21356 | if self.options.annotate: | ||
|
r32719 | adir = os.path.join(self._outputdir, 'annotated') | ||
|
r21356 | if not os.path.isdir(adir): | ||
os.mkdir(adir) | ||||
|
r24504 | cov.annotate(directory=adir, omit=omit) | ||
|
r21356 | |||
|
r21365 | def _findprogram(self, program): | ||
"""Search PATH for a executable program""" | ||||
|
r25161 | dpb = _bytespath(os.defpath) | ||
sepb = _bytespath(os.pathsep) | ||||
|
r25038 | for p in osenvironb.get(b'PATH', dpb).split(sepb): | ||
|
r21365 | name = os.path.join(p, program) | ||
if os.name == 'nt' or os.access(name, os.X_OK): | ||||
return name | ||||
return None | ||||
|
r21374 | def _checktools(self): | ||
|
r21536 | """Ensure tools required to run tests are present.""" | ||
|
r21365 | for p in self.REQUIREDTOOLS: | ||
if os.name == 'nt' and not p.endswith('.exe'): | ||||
p += '.exe' | ||||
found = self._findprogram(p) | ||||
if found: | ||||
vlog("# Found prerequisite", p, "at", found) | ||||
else: | ||||
|
r28698 | print("WARNING: Did not find prerequisite tool: %s " % | ||
p.decode("utf-8")) | ||||
|
r21365 | |||
|
r13347 | if __name__ == '__main__': | ||
|
r21377 | runner = TestRunner() | ||
|
r22120 | |||
try: | ||||
import msvcrt | ||||
msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY) | ||||
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) | ||||
msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY) | ||||
except ImportError: | ||||
pass | ||||
|
r21377 | sys.exit(runner.run(sys.argv[1:])) | ||