run-tests.py
3955 lines
| 134.4 KiB
| text/x-python
|
PythonLexer
/ tests / run-tests.py
|
r46434 | #!/usr/bin/env python3 | ||
|
r2110 | # | ||
# run-tests.py - Run a set of tests on Mercurial | ||||
# | ||||
|
r47575 | # Copyright 2006 Olivia Mackall <olivia@selenic.com> | ||
|
r2110 | # | ||
|
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 | ||
|
r35191 | import collections | ||
|
r46569 | import contextlib | ||
|
r2571 | import difflib | ||
|
r29485 | import distutils.version as version | ||
|
r2571 | import errno | ||
|
r28126 | import json | ||
|
r40281 | import multiprocessing | ||
|
r2571 | import os | ||
|
r44973 | import platform | ||
|
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 | ||
|
r39289 | import uuid | ||
|
r29485 | import xml.dom.minidom as minidom | ||
r48373 | WINDOWS = os.name == r'nt' | |||
|
r25031 | try: | ||
import Queue as queue | ||||
except ImportError: | ||||
import queue | ||||
|
r2110 | |||
|
r33121 | try: | ||
import shlex | ||||
|
r43346 | |||
|
r33121 | shellquote = shlex.quote | ||
except (ImportError, AttributeError): | ||||
import pipes | ||||
|
r43346 | |||
|
r33121 | shellquote = pipes.quote | ||
r48373 | ||||
|
r14019 | processlock = threading.Lock() | ||
|
r19413 | |||
|
r33552 | pygmentspresent = False | ||
|
r48089 | try: # is pygments installed | ||
import pygments | ||||
import pygments.lexers as lexers | ||||
import pygments.lexer as lexer | ||||
import pygments.formatters as formatters | ||||
import pygments.token as token | ||||
import pygments.style as style | ||||
r48373 | if WINDOWS: | |||
|
r48089 | hgpath = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) | ||
sys.path.append(hgpath) | ||||
try: | ||||
from mercurial import win32 # pytype: disable=import-error | ||||
# Don't check the result code because it fails on heptapod, but | ||||
# something is able to convert to color anyway. | ||||
win32.enablevtmode() | ||||
finally: | ||||
sys.path = sys.path[:-1] | ||||
pygmentspresent = True | ||||
difflexer = lexers.DiffLexer() | ||||
terminal256formatter = formatters.Terminal256Formatter() | ||||
except ImportError: | ||||
pass | ||||
|
r33420 | |||
|
r33813 | if pygmentspresent: | ||
|
r43346 | |||
|
r33813 | 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 = { | ||||
|
r43346 | skipped: '#e5e5e5', | ||
skippedname: '#00ffff', | ||||
failed: '#7f0000', | ||||
failedname: '#ff0000', | ||||
|
r33813 | } | ||
class TestRunnerLexer(lexer.RegexLexer): | ||||
|
r38309 | testpattern = r'[\w-]+\.(t|py)(#[a-zA-Z0-9_\-\.]+)?' | ||
|
r33813 | tokens = { | ||
'root': [ | ||||
(r'^Skipped', token.Generic.Skipped, 'skipped'), | ||||
(r'^Failed ', token.Generic.Failed, 'failed'), | ||||
(r'^ERROR: ', token.Generic.Failed, 'failed'), | ||||
], | ||||
'skipped': [ | ||||
|
r35866 | (testpattern, token.Generic.SName), | ||
|
r33813 | (r':.*', token.Generic.Skipped), | ||
], | ||||
'failed': [ | ||||
|
r35866 | (testpattern, token.Generic.FName), | ||
|
r33813 | (r'(:| ).*', token.Generic.Failed), | ||
|
r43346 | ], | ||
|
r33813 | } | ||
|
r33868 | runnerformatter = formatters.Terminal256Formatter(style=TestRunnerStyle) | ||
runnerlexer = TestRunnerLexer() | ||||
|
r39681 | origenviron = os.environ.copy() | ||
r48373 | ||||
|
r25160 | if sys.version_info > (3, 5, 0): | ||
|
r25157 | PYTHON3 = True | ||
|
r43346 | xrange = range # we use xrange in one place, and we'd rather not use range | ||
|
r44935 | def _sys2bytes(p): | ||
|
r33676 | if p is None: | ||
return p | ||||
|
r25161 | return p.encode('utf-8') | ||
|
r25162 | |||
|
r44935 | def _bytes2sys(p): | ||
|
r33676 | if p is None: | ||
return p | ||||
|
r25162 | return p.decode('utf-8') | ||
|
r39681 | osenvironb = getattr(os, 'environb', None) | ||
if osenvironb is None: | ||||
|
r39750 | # Windows lacks os.environb, for instance. A proxy over the real thing | ||
# instead of a copy allows the environment to be updated via bytes on | ||||
# all platforms. | ||||
class environbytes(object): | ||||
def __init__(self, strenv): | ||||
self.__len__ = strenv.__len__ | ||||
self.clear = strenv.clear | ||||
self._strenv = strenv | ||||
|
r43346 | |||
|
r39750 | def __getitem__(self, k): | ||
|
r44935 | v = self._strenv.__getitem__(_bytes2sys(k)) | ||
return _sys2bytes(v) | ||||
|
r43346 | |||
|
r39750 | def __setitem__(self, k, v): | ||
|
r44935 | self._strenv.__setitem__(_bytes2sys(k), _bytes2sys(v)) | ||
|
r43346 | |||
|
r39750 | def __delitem__(self, k): | ||
|
r44935 | self._strenv.__delitem__(_bytes2sys(k)) | ||
|
r43346 | |||
|
r39750 | def __contains__(self, k): | ||
|
r44935 | return self._strenv.__contains__(_bytes2sys(k)) | ||
|
r43346 | |||
|
r39750 | def __iter__(self): | ||
|
r44935 | return iter([_sys2bytes(k) for k in iter(self._strenv)]) | ||
|
r43346 | |||
|
r39750 | def get(self, k, default=None): | ||
|
r44935 | v = self._strenv.get(_bytes2sys(k), _bytes2sys(default)) | ||
return _sys2bytes(v) | ||||
|
r43346 | |||
|
r39750 | def pop(self, k, default=None): | ||
|
r44935 | v = self._strenv.pop(_bytes2sys(k), _bytes2sys(default)) | ||
return _sys2bytes(v) | ||||
|
r39750 | |||
osenvironb = environbytes(os.environ) | ||||
|
r39681 | |||
|
r39754 | getcwdb = getattr(os, 'getcwdb') | ||
r48373 | if not getcwdb or WINDOWS: | |||
|
r44935 | getcwdb = lambda: _sys2bytes(os.getcwd()) | ||
|
r39754 | |||
|
r25160 | elif sys.version_info >= (3, 0, 0): | ||
|
r43346 | print( | ||
'%s is only supported on Python 3.5+ and 2.7, not %s' | ||||
% (sys.argv[0], '.'.join(str(v) for v in sys.version_info[:3])) | ||||
) | ||||
sys.exit(70) # EX_SOFTWARE from `man 3 sysexit` | ||||
|
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. | ||||
|
r44935 | def _sys2bytes(p): | ||
|
r25161 | return p | ||
|
r25033 | |||
|
r44935 | _bytes2sys = _sys2bytes | ||
|
r39681 | osenvironb = os.environ | ||
|
r39754 | getcwdb = os.getcwd | ||
|
r25162 | |||
|
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 | ||||
|
r43346 | |||
|
r31011 | # useipv6 will be set by parseargs | ||
useipv6 = None | ||||
|
r30984 | |||
|
r43346 | |||
|
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: | ||
|
r46569 | with contextlib.closing(socket.socket(family, socket.SOCK_STREAM)) as s: | ||
s.bind(('localhost', port)) | ||||
|
r30987 | return True | ||
except socket.error as exc: | ||||
r48373 | if WINDOWS and exc.errno == errno.WSAEACCES: | |||
|
r47045 | return False | ||
|
r47983 | elif PYTHON3: | ||
# TODO: make a proper exception handler after dropping py2. This | ||||
# works because socket.error is an alias for OSError on py3, | ||||
# which is also the baseclass of PermissionError. | ||||
if isinstance(exc, PermissionError): | ||||
return False | ||||
if exc.errno not in ( | ||||
|
r43346 | errno.EADDRINUSE, | ||
errno.EADDRNOTAVAIL, | ||||
errno.EPROTONOSUPPORT, | ||||
): | ||||
|
r30987 | raise | ||
|
r30886 | return False | ||
|
r24967 | |||
|
r43346 | |||
|
r8280 | closefds = os.name == 'posix' | ||
|
r43346 | |||
|
r19262 | def Popen4(cmd, wd, timeout, env=None): | ||
|
r14019 | processlock.acquire() | ||
|
r43346 | p = subprocess.Popen( | ||
|
r44935 | _bytes2sys(cmd), | ||
|
r43346 | shell=True, | ||
bufsize=-1, | ||||
|
r44935 | cwd=_bytes2sys(wd), | ||
|
r43346 | env=env, | ||
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: | ||
|
r43346 | |||
|
r14001 | def t(): | ||
start = time.time() | ||||
while time.time() - start < timeout and p.returncode is None: | ||||
|
r43346 | time.sleep(0.1) | ||
|
r14001 | p.timeout = True | ||
r47680 | vlog('# Timout reached for process %d' % p.pid) | |||
|
r14001 | if p.returncode is None: | ||
|
r14821 | terminate(p) | ||
|
r43346 | |||
|
r14001 | threading.Thread(target=t).start() | ||
|
r8280 | return p | ||
|
r43346 | |||
|
r42723 | if sys.executable: | ||
sysexecutable = sys.executable | ||||
elif os.environ.get('PYTHONEXECUTABLE'): | ||||
sysexecutable = os.environ['PYTHONEXECUTABLE'] | ||||
elif os.environ.get('PYTHON'): | ||||
sysexecutable = os.environ['PYTHON'] | ||||
else: | ||||
raise AssertionError('Could not find Python interpreter') | ||||
|
r44935 | PYTHON = _sys2bytes(sysexecutable.replace('\\', '/')) | ||
|
r25041 | IMPL_PATH = b'PYTHONPATH' | ||
|
r10758 | if 'java' in sys.platform: | ||
|
r25041 | IMPL_PATH = b'JYTHONPATH' | ||
|
r4881 | |||
r45122 | default_defaults = { | |||
|
r40281 | 'jobs': ('HGTEST_JOBS', multiprocessing.cpu_count()), | ||
|
r47814 | 'timeout': ('HGTEST_TIMEOUT', 360), | ||
r41966 | 'slowtimeout': ('HGTEST_SLOWTIMEOUT', 1500), | |||
|
r6366 | 'port': ('HGTEST_PORT', 20059), | ||
|
r15941 | 'shell': ('HGTEST_SHELL', 'sh'), | ||
|
r6366 | } | ||
r45122 | defaults = default_defaults.copy() | |||
|
r43346 | |||
|
r28644 | def canonpath(path): | ||
return os.path.realpath(os.path.expanduser(path)) | ||||
|
r43346 | |||
|
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: | ||
|
r47984 | # Ensure path entries are compatible with os.path.relpath() | ||
entries[os.path.normpath(line)] = filename | ||||
|
r14493 | |||
f.close() | ||||
return entries | ||||
|
r43346 | |||
|
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. | ||||
""" | ||||
|
r38860 | cases = [] | ||
|
r32317 | try: | ||
with open(path, 'rb') as f: | ||||
for l in f: | ||||
if l.startswith(b'#testcases '): | ||||
|
r38860 | cases.append(sorted(l[11:].split())) | ||
|
r32317 | except IOError as ex: | ||
if ex.errno != errno.ENOENT: | ||||
raise | ||||
return cases | ||||
|
r43346 | |||
|
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') | ||
|
r43346 | selection.add_argument( | ||
'--allow-slow-tests', | ||||
action='store_true', | ||||
help='allow extremely slow tests', | ||||
) | ||||
selection.add_argument( | ||||
"--blacklist", | ||||
action="append", | ||||
help="skip tests listed in the specified blacklist file", | ||||
) | ||||
selection.add_argument( | ||||
"--changed", | ||||
help="run tests that are changed in parent rev or working directory", | ||||
) | ||||
selection.add_argument( | ||||
"-k", "--keywords", help="run tests matching keywords" | ||||
) | ||||
selection.add_argument( | ||||
"-r", "--retest", action="store_true", help="retest failed tests" | ||||
) | ||||
selection.add_argument( | ||||
"--test-list", | ||||
action="append", | ||||
help="read tests to run from the specified file", | ||||
) | ||||
selection.add_argument( | ||||
"--whitelist", | ||||
action="append", | ||||
help="always run tests listed in the specified whitelist file", | ||||
) | ||||
selection.add_argument( | ||||
'tests', metavar='TESTS', nargs='*', help='Tests to run' | ||||
) | ||||
|
r35189 | |||
harness = parser.add_argument_group('Test Harness Behavior') | ||||
|
r43346 | 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" | ||
|
r43346 | " rather than capturing and diffing it (disables timeout)", | ||
) | ||||
harness.add_argument( | ||||
"-f", | ||||
"--first", | ||||
action="store_true", | ||||
help="exit on the first test failure", | ||||
) | ||||
harness.add_argument( | ||||
"-i", | ||||
"--interactive", | ||||
action="store_true", | ||||
help="prompt to accept changed output", | ||||
) | ||||
harness.add_argument( | ||||
"-j", | ||||
"--jobs", | ||||
type=int, | ||||
|
r8091 | help="number of jobs to run in parallel" | ||
|
r43346 | " (default: $%s or %d)" % defaults['jobs'], | ||
) | ||||
harness.add_argument( | ||||
"--keep-tmpdir", | ||||
action="store_true", | ||||
help="keep temporary directory after running tests", | ||||
) | ||||
harness.add_argument( | ||||
'--known-good-rev', | ||||
metavar="known_good_rev", | ||||
help=( | ||||
"Automatically bisect any failures using this " | ||||
"revision as a known-good revision." | ||||
), | ||||
) | ||||
harness.add_argument( | ||||
"--list-tests", | ||||
action="store_true", | ||||
help="list tests instead of running them", | ||||
) | ||||
harness.add_argument( | ||||
"--loop", action="store_true", help="loop tests repeatedly" | ||||
) | ||||
harness.add_argument( | ||||
'--random', action="store_true", help='run tests in random order' | ||||
) | ||||
harness.add_argument( | ||||
'--order-by-runtime', | ||||
action="store_true", | ||||
help='run slowest tests first, according to .testtimes', | ||||
) | ||||
harness.add_argument( | ||||
"-p", | ||||
"--port", | ||||
type=int, | ||||
|
r35189 | help="port on which servers should listen" | ||
|
r43346 | " (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, | ||||
|
r35189 | help="kill errant slow tests after SLOWTIMEOUT seconds" | ||
|
r43346 | " (default: $%s or %d)" % defaults['slowtimeout'], | ||
) | ||||
harness.add_argument( | ||||
"-t", | ||||
"--timeout", | ||||
type=int, | ||||
|
r35189 | help="kill errant tests after TIMEOUT seconds" | ||
|
r43346 | " (default: $%s or %d)" % defaults['timeout'], | ||
) | ||||
harness.add_argument( | ||||
"--tmpdir", | ||||
|
r35189 | help="run tests in the given temporary directory" | ||
|
r43346 | " (implies --keep-tmpdir)", | ||
) | ||||
harness.add_argument( | ||||
"-v", "--verbose", action="store_true", help="output verbose messages" | ||||
) | ||||
|
r35189 | |||
hgconf = parser.add_argument_group('Mercurial Configuration') | ||||
|
r43346 | hgconf.add_argument( | ||
"--chg", | ||||
action="store_true", | ||||
help="install and use chg wrapper in place of hg", | ||||
) | ||||
|
r45105 | hgconf.add_argument( | ||
|
r46554 | "--chg-debug", | ||
action="store_true", | ||||
help="show chg debug logs", | ||||
|
r45105 | ) | ||
|
r47426 | hgconf.add_argument( | ||
"--rhg", | ||||
action="store_true", | ||||
help="install and use rhg Rust implementation in place of hg", | ||||
) | ||||
|
r43346 | hgconf.add_argument("--compiler", help="compiler to build with") | ||
hgconf.add_argument( | ||||
'--extra-config-opt', | ||||
action="append", | ||||
default=[], | ||||
help='set the given config opt in the test hgrc', | ||||
) | ||||
hgconf.add_argument( | ||||
"-l", | ||||
"--local", | ||||
action="store_true", | ||||
|
r29583 | help="shortcut for --with-hg=<testdir>/../hg, " | ||
|
r47426 | "--with-rhg=<testdir>/../rust/target/release/rhg if --rhg is set, " | ||
|
r43346 | "and --with-chg=<testdir>/../contrib/chg/chg if --chg is set", | ||
) | ||||
hgconf.add_argument( | ||||
"--ipv6", | ||||
action="store_true", | ||||
help="prefer IPv6 to IPv4 for network related tests", | ||||
) | ||||
hgconf.add_argument( | ||||
"--pure", | ||||
action="store_true", | ||||
help="use pure Python code instead of C extensions", | ||||
) | ||||
hgconf.add_argument( | ||||
|
r44973 | "--rust", | ||
|
r43346 | action="store_true", | ||
|
r44973 | help="use Rust code alongside C extensions", | ||
) | ||||
hgconf.add_argument( | ||||
"--no-rust", | ||||
action="store_true", | ||||
help="do not use Rust code even if compiled", | ||||
|
r43346 | ) | ||
hgconf.add_argument( | ||||
"--with-chg", | ||||
metavar="CHG", | ||||
help="use specified chg wrapper in place of hg", | ||||
) | ||||
hgconf.add_argument( | ||||
|
r47426 | "--with-rhg", | ||
metavar="RHG", | ||||
help="use specified rhg Rust implementation in place of hg", | ||||
) | ||||
hgconf.add_argument( | ||||
|
r43346 | "--with-hg", | ||
|
r8674 | metavar="HG", | ||
help="test using specified hg script rather than a " | ||||
|
r43346 | "temporary installation", | ||
) | ||||
|
r35189 | |||
reporting = parser.add_argument_group('Results Reporting') | ||||
|
r43346 | reporting.add_argument( | ||
"-C", | ||||
"--annotate", | ||||
action="store_true", | ||||
help="output files annotated with coverage", | ||||
) | ||||
reporting.add_argument( | ||||
"--color", | ||||
choices=["always", "auto", "never"], | ||||
|
r35189 | default=os.environ.get('HGRUNTESTSCOLOR', 'auto'), | ||
|
r43346 | help="colorisation: always|auto|never (default: auto)", | ||
) | ||||
reporting.add_argument( | ||||
"-c", | ||||
"--cover", | ||||
action="store_true", | ||||
help="print a test coverage report", | ||||
) | ||||
reporting.add_argument( | ||||
'--exceptions', | ||||
action='store_true', | ||||
help='log all exceptions and generate an exception report', | ||||
) | ||||
reporting.add_argument( | ||||
"-H", | ||||
"--htmlcov", | ||||
action="store_true", | ||||
help="create an HTML report of the coverage of the files", | ||||
) | ||||
reporting.add_argument( | ||||
"--json", | ||||
action="store_true", | ||||
help="store test result data in 'report.json' file", | ||||
) | ||||
reporting.add_argument( | ||||
"--outputdir", | ||||
help="directory to write error logs to (default=test directory)", | ||||
) | ||||
reporting.add_argument( | ||||
"-n", "--nodiff", action="store_true", help="skip showing test changes" | ||||
) | ||||
reporting.add_argument( | ||||
"-S", | ||||
"--noskips", | ||||
action="store_true", | ||||
help="don't report skip tests verbosely", | ||||
) | ||||
reporting.add_argument( | ||||
"--time", action="store_true", help="time how long each test takes" | ||||
) | ||||
reporting.add_argument("--view", help="external diff viewer") | ||||
reporting.add_argument( | ||||
"--xunit", help="record xunit results at specified path" | ||||
) | ||||
|
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 | ||||
|
r43346 | |||
|
r21008 | 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 | |||
|
r44973 | if platform.python_implementation() != 'CPython' and options.rust: | ||
parser.error('Rust extensions are only available with CPython') | ||||
if options.pure and options.rust: | ||||
parser.error('--rust cannot be used with --pure') | ||||
if options.rust and options.no_rust: | ||||
parser.error('--rust cannot be used with --no-rust') | ||||
|
r8674 | if options.local: | ||
|
r47426 | if options.with_hg or options.with_rhg or options.with_chg: | ||
parser.error( | ||||
'--local cannot be used with --with-hg or --with-rhg or --with-chg' | ||||
) | ||||
|
r44935 | testdir = os.path.dirname(_sys2bytes(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')) | ||||
|
r47426 | if options.rhg: | ||
pathandattrs.append((b'rust/target/release/rhg', 'with_rhg')) | ||||
|
r29582 | for relpath, attr in pathandattrs: | ||
binpath = os.path.join(reporootdir, relpath) | ||||
r48373 | if not (WINDOWS or os.access(binpath, os.X_OK)): | |||
|
r43346 | parser.error( | ||
'--local specified, but %r not found or ' | ||||
'not executable' % binpath | ||||
) | ||||
|
r44935 | setattr(options, attr, _bytes2sys(binpath)) | ||
|
r43085 | |||
if options.with_hg: | ||||
|
r44935 | options.with_hg = canonpath(_sys2bytes(options.with_hg)) | ||
|
r43346 | if not ( | ||
os.path.isfile(options.with_hg) | ||||
and os.access(options.with_hg, os.X_OK) | ||||
): | ||||
|
r43085 | parser.error('--with-hg must specify an executable hg script') | ||
if os.path.basename(options.with_hg) not in [b'hg', b'hg.exe']: | ||||
r48383 | msg = 'warning: --with-hg should specify an hg script, not: %s\n' | |||
msg %= _bytes2sys(os.path.basename(options.with_hg)) | ||||
sys.stderr.write(msg) | ||||
|
r43085 | sys.stderr.flush() | ||
|
r8674 | |||
r48373 | if (options.chg or options.with_chg) and WINDOWS: | |||
|
r28143 | parser.error('chg does not work on %s' % os.name) | ||
r48373 | if (options.rhg or options.with_rhg) and WINDOWS: | |||
|
r47426 | parser.error('rhg does not work on %s' % os.name) | ||
|
r28142 | if options.with_chg: | ||
|
r28143 | options.chg = False # no installation to temporary location | ||
|
r44935 | options.with_chg = canonpath(_sys2bytes(options.with_chg)) | ||
|
r43346 | if not ( | ||
os.path.isfile(options.with_chg) | ||||
and os.access(options.with_chg, os.X_OK) | ||||
): | ||||
|
r28142 | parser.error('--with-chg must specify a chg executable') | ||
|
r47426 | if options.with_rhg: | ||
options.rhg = False # no installation to temporary location | ||||
options.with_rhg = canonpath(_sys2bytes(options.with_rhg)) | ||||
if not ( | ||||
os.path.isfile(options.with_rhg) | ||||
and os.access(options.with_rhg, os.X_OK) | ||||
): | ||||
parser.error('--with-rhg must specify a rhg executable') | ||||
|
r28143 | if options.chg and options.with_hg: | ||
# chg shares installation location with hg | ||||
|
r43346 | parser.error( | ||
'--chg does not work when --with-hg is specified ' | ||||
'(use --with-chg instead)' | ||||
) | ||||
|
r47426 | if options.rhg and options.with_hg: | ||
# rhg shares installation location with hg | ||||
parser.error( | ||||
'--rhg does not work when --with-hg is specified ' | ||||
'(use --with-rhg instead)' | ||||
) | ||||
if options.rhg and options.chg: | ||||
parser.error('--rhg and --chg do not work together') | ||||
|
r28142 | |||
|
r33567 | if options.color == 'always' and not pygmentspresent: | ||
|
r43346 | sys.stderr.write( | ||
'warning: --color=always ignored because ' | ||||
'pygments is not installed\n' | ||||
) | ||||
|
r33567 | |||
|
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 | ||||
|
r43346 | useipv6 = (not checksocketfamily('AF_INET')) and checksocketfamily( | ||
'AF_INET6' | ||||
) | ||||
|
r31011 | |||
|
r15859 | options.anycoverage = options.cover or options.annotate or options.htmlcov | ||
|
r10648 | if options.anycoverage: | ||
try: | ||||
import coverage | ||||
|
r43346 | |||
|
r10648 | 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 | ||||
|
r43346 | parser.error( | ||
"sorry, coverage options do not work when --local " "is specified" | ||||
) | ||||
|
r8674 | |||
|
r24506 | if options.anycoverage and options.with_hg: | ||
|
r43346 | parser.error( | ||
"sorry, coverage options do not work when --with-hg " "is specified" | ||||
) | ||||
|
r24506 | |||
|
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']: | ||||
|
r43346 | sys.stderr.write('warning: --timeout option ignored with --debug\n') | ||
|
r27141 | if options.slowtimeout != defaults['slowtimeout']: | ||
sys.stderr.write( | ||||
|
r43346 | 'warning: --slowtimeout option ignored with --debug\n' | ||
) | ||||
|
r9707 | options.timeout = 0 | ||
|
r27141 | options.slowtimeout = 0 | ||
|
r28582 | |||
|
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 | |||
|
r43346 | |||
|
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) | ||||
|
r43346 | |||
|
r41023 | def makecleanable(path): | ||
"""Try to fix directory permission recursively so that the entire tree | ||||
can be deleted""" | ||||
for dirpath, dirnames, _filenames in os.walk(path, topdown=True): | ||||
for d in dirnames: | ||||
p = os.path.join(dirpath, d) | ||||
try: | ||||
os.chmod(p, os.stat(p).st_mode & 0o777 | 0o700) # chmod u+rwx | ||||
except OSError: | ||||
pass | ||||
|
r43346 | |||
|
r25045 | _unified_diff = difflib.unified_diff | ||
|
r25159 | if PYTHON3: | ||
|
r25045 | import functools | ||
|
r43346 | |||
|
r25045 | _unified_diff = functools.partial(difflib.diff_bytes, difflib.unified_diff) | ||
|
r43346 | |||
|
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( | ||
|
r43346 | b'+ abort: child process failed to start' | ||
): | ||||
|
r21022 | servefail = True | ||
|
r21521 | return servefail, lines | ||
|
r2110 | |||
|
r43346 | |||
|
r19250 | verbose = False | ||
|
r43346 | |||
|
r19250 | def vlog(*msg): | ||
|
r21535 | """Log only when in verbose mode.""" | ||
if verbose is False: | ||||
return | ||||
return log(*msg) | ||||
|
r19250 | |||
|
r43346 | |||
|
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 | ||||
|
r41681 | optline = re.compile(br'(.*) \((.+?) !\)\n$') | ||
|
r31829 | |||
|
r43346 | |||
|
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 | |||
|
r43346 | |||
|
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 | |||
|
r43346 | |||
|
r33931 | def highlightdiff(line, color): | ||
if not color: | ||||
return line | ||||
assert pygmentspresent | ||||
|
r43346 | 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) | ||||
|
r43346 | |||
|
r14821 | def terminate(proc): | ||
|
r32303 | """Terminate subprocess""" | ||
|
r14821 | vlog('# Terminating process %d' % proc.pid) | ||
try: | ||||
|
r32303 | proc.terminate() | ||
|
r14821 | except OSError: | ||
pass | ||||
|
r43346 | |||
|
r19263 | def killdaemons(pidfile): | ||
|
r29485 | import killdaemons as killmod | ||
|
r43346 | |||
return killmod.killdaemons(pidfile, tryhard=False, remove=True, 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 | ||||
|
r43346 | def __init__( | ||
self, | ||||
path, | ||||
outputdir, | ||||
tmpdir, | ||||
keeptmpdir=False, | ||||
debug=False, | ||||
first=False, | ||||
timeout=None, | ||||
startport=None, | ||||
extraconfigopts=None, | ||||
shell=None, | ||||
hgcommand=None, | ||||
slowtimeout=None, | ||||
usechg=False, | ||||
|
r45105 | chgdebug=False, | ||
|
r43346 | 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 | |||
|
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 | ||
|
r46086 | self.relpath = os.path.relpath(path) | ||
|
r25039 | self.bname = os.path.basename(path) | ||
|
r44935 | self.name = _bytes2sys(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 | ||
|
r35586 | self._first = first | ||
|
r21513 | self._timeout = timeout | ||
|
r27141 | self._slowtimeout = slowtimeout | ||
|
r21514 | self._startport = startport | ||
|
r21515 | self._extraconfigopts = extraconfigopts or [] | ||
|
r44935 | self._shell = _sys2bytes(shell) | ||
|
r28099 | self._hgcommand = hgcommand or b'hg' | ||
|
r28620 | self._usechg = usechg | ||
|
r45105 | self._chgdebug = chgdebug | ||
|
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: | ||
|
r43346 | 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: | ||
|
r43346 | self._chgsockdir = os.path.join( | ||
self._threadtmp, b'%s.chgsock' % name | ||||
) | ||||
|
r28620 | 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: | ||
|
r43346 | if out is None: # Debug mode, nothing to parse. | ||
|
r21324 | 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. | ||
|
r43346 | if ( | ||
(ret != 0 or out != self._refout) | ||||
and not self._skipped | ||||
and not self._debug | ||||
): | ||||
|
r35466 | with open(self.errpath, 'wb') as f: | ||
for line in out: | ||||
f.write(line) | ||||
|
r21614 | |||
|
r21521 | # The result object handles diff calculation for us. | ||
|
r35586 | with firstlock: | ||
if self._result.addOutputMismatch(self, ret, out, self._refout): | ||||
# change was accepted, skip failing | ||||
return | ||||
if self._first: | ||||
global firsterror | ||||
firsterror = True | ||||
|
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: | ||
|
r43346 | log( | ||
'\nKeeping testtmp dir: %s\nKeeping threadtmp dir: %s' | ||||
|
r46554 | % ( | ||
_bytes2sys(self._testtmp), | ||||
_bytes2sys(self._threadtmp), | ||||
) | ||||
|
r43346 | ) | ||
|
r26422 | else: | ||
|
r41023 | try: | ||
shutil.rmtree(self._testtmp) | ||||
except OSError: | ||||
# unreadable directory may be left in $TESTTMP; fix permission | ||||
# and try again | ||||
makecleanable(self._testtmp) | ||||
shutil.rmtree(self._testtmp, True) | ||||
|
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) | ||||
|
r43346 | if ( | ||
(self._ret != 0 or self._out != self._refout) | ||||
and not self._skipped | ||||
and not self._debug | ||||
and self._out | ||||
): | ||||
|
r35466 | with open(self.errpath, 'wb') as f: | ||
for line in self._out: | ||||
f.write(line) | ||||
|
r21455 | |||
|
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), | ||||
|
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$'), | ||
|
r43346 | ] | ||
|
r28055 | r.append((self._escapepath(self._testtmp), b'$TESTTMP')) | ||
r48373 | if WINDOWS: | |||
|
r48371 | # JSON output escapes backslashes in Windows paths, so also catch a | ||
# double-escape. | ||||
replaced = self._testtmp.replace(b'\\', br'\\') | ||||
r.append((self._escapepath(replaced), b'$STR_REPR_TESTTMP')) | ||||
|
r21298 | |||
|
r35195 | replacementfile = os.path.join(self._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) | ||||
|
r36009 | for value in data.get('substitutions', ()): | ||
if len(value) != 2: | ||||
msg = 'malformatted substitution in %s: %r' | ||||
msg %= (replacementfile, value) | ||||
raise ValueError(msg) | ||||
r.append(value) | ||||
|
r28055 | return r | ||
def _escapepath(self, p): | ||||
r48373 | if WINDOWS: | |||
|
r43346 | return b''.join( | ||
c.isalpha() | ||||
and b'[%s%s]' % (c.lower(), c.upper()) | ||||
or c in b'/\\' | ||||
and br'[/\\]' | ||||
or c.isdigit() | ||||
and c | ||||
or b'\\' + c | ||||
for c in [p[i : i + 1] for i in range(len(p))] | ||||
|
r28055 | ) | ||
|
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') | ||||
|
r44935 | testenv['HGTEST_RESTOREENV'] = _bytes2sys(scriptpath) | ||
|
r33121 | |||
# 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.""" | ||
|
r43346 | |||
|
r28169 | def defineport(i): | ||
offset = '' if i == 0 else '%s' % i | ||||
env["HGPORT%s" % offset] = '%s' % (self._startport + i) | ||||
|
r43346 | |||
|
r21299 | env = os.environ.copy() | ||
|
r35585 | env['PYTHONUSERBASE'] = sysconfig.get_config_var('userbase') or '' | ||
|
r31950 | env['HGEMITWARNINGS'] = '1' | ||
|
r44935 | env['TESTTMP'] = _bytes2sys(self._testtmp) | ||
r48093 | uid_file = os.path.join(_bytes2sys(self._testtmp), 'UID') | |||
env['HGTEST_UUIDFILE'] = uid_file | ||||
|
r36054 | env['TESTNAME'] = self.name | ||
|
r44935 | env['HOME'] = _bytes2sys(self._testtmp) | ||
r48373 | if WINDOWS: | |||
|
r47629 | env['REALUSERPROFILE'] = env['USERPROFILE'] | ||
|
r46708 | # py3.8+ ignores HOME: https://bugs.python.org/issue36264 | ||
env['USERPROFILE'] = env['HOME'] | ||||
r45122 | formated_timeout = _bytes2sys(b"%d" % default_defaults['timeout'][1]) | |||
env['HGTEST_TIMEOUT_DEFAULT'] = formated_timeout | ||||
env['HGTEST_TIMEOUT'] = _bytes2sys(b"%d" % self._timeout) | ||||
|
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) | ||||
|
r44935 | env["HGRCPATH"] = _bytes2sys(os.path.join(self._threadtmp, b'.hgrc')) | ||
env["DAEMON_PIDS"] = _bytes2sys( | ||||
|
r43346 | os.path.join(self._threadtmp, b'daemon.pids') | ||
) | ||||
env["HGEDITOR"] = ( | ||||
'"' + sysexecutable + '"' + ' -c "import sys; sys.exit(0)"' | ||||
) | ||||
env["HGUSER"] = "test" | ||||
|
r21299 | env["HGENCODING"] = "ascii" | ||
env["HGENCODINGMODE"] = "strict" | ||||
|
r39155 | env["HGHOSTNAME"] = "test-hostname" | ||
|
r31003 | env['HGIPV6'] = str(int(self._useipv6)) | ||
|
r40526 | # See contrib/catapipe.py for how to use this functionality. | ||
|
r40525 | if 'HGTESTCATAPULTSERVERPIPE' not in env: | ||
# If we don't have HGTESTCATAPULTSERVERPIPE explicitly set, pull the | ||||
# non-test one in as a default, otherwise set to devnull | ||||
|
r41925 | env['HGTESTCATAPULTSERVERPIPE'] = env.get( | ||
|
r43346 | 'HGCATAPULTSERVERPIPE', os.devnull | ||
) | ||||
|
r21299 | |||
|
r37360 | extraextensions = [] | ||
for opt in self._extraconfigopts: | ||||
|
r46707 | section, key = opt.split('.', 1) | ||
|
r37360 | if section != 'extensions': | ||
continue | ||||
|
r46707 | name = key.split('=', 1)[0] | ||
|
r37360 | extraextensions.append(name) | ||
if extraextensions: | ||||
|
r46707 | env['HGTESTEXTRAEXTENSIONS'] = ' '.join(extraextensions) | ||
|
r37360 | |||
|
r31006 | # LOCALIP could be ::1 or 127.0.0.1. Useful for tests that require raw | ||
# IP addresses. | ||||
|
r44935 | env['LOCALIP'] = _bytes2sys(self._localip()) | ||
|
r31006 | |||
|
r41017 | # This has the same effect as Py_LegacyWindowsStdioFlag in exewrapper.c, | ||
# but this is needed for testing python instances like dummyssh, | ||||
# dummysmtpd.py, and dumbhttp.py. | ||||
r48373 | if PYTHON3 and WINDOWS: | |||
|
r41017 | env['PYTHONLEGACYWINDOWSSTDIO'] = '1' | ||
|
r44271 | # Modified HOME in test environment can confuse Rust tools. So set | ||
# CARGO_HOME and RUSTUP_HOME automatically if a Rust toolchain is | ||||
# present and these variables aren't already defined. | ||||
cargo_home_path = os.path.expanduser('~/.cargo') | ||||
rustup_home_path = os.path.expanduser('~/.rustup') | ||||
if os.path.exists(cargo_home_path) and b'CARGO_HOME' not in osenvironb: | ||||
env['CARGO_HOME'] = cargo_home_path | ||||
if ( | ||||
os.path.exists(rustup_home_path) | ||||
and b'RUSTUP_HOME' not in osenvironb | ||||
): | ||||
env['RUSTUP_HOME'] = rustup_home_path | ||||
|
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' | ||||
|
r40505 | dropped = [ | ||
'CDPATH', | ||||
'CHGDEBUG', | ||||
'EDITOR', | ||||
'GREP_OPTIONS', | ||||
'HG', | ||||
|
r40506 | 'HGMERGE', | ||
|
r40505 | 'HGPLAIN', | ||
'HGPLAINEXCEPT', | ||||
'HGPROF', | ||||
'http_proxy', | ||||
'no_proxy', | ||||
'NO_PROXY', | ||||
'PAGER', | ||||
'VISUAL', | ||||
] | ||||
for k in dropped: | ||||
|
r21299 | if k in env: | ||
del env[k] | ||||
# unset env related to hooks | ||||
|
r36539 | for k in list(env): | ||
|
r21299 | if k.startswith('HG_'): | ||
del env[k] | ||||
|
r28620 | if self._usechg: | ||
env['CHGSOCKNAME'] = os.path.join(self._chgsockdir, b'server') | ||||
|
r45105 | if self._chgdebug: | ||
env['CHGDEBUG'] = 'true' | ||||
|
r28620 | |||
|
r21299 | return env | ||
|
r21382 | def _createhgrc(self, path): | ||
|
r21536 | """Create an hgrc file for this test.""" | ||
|
r35466 | with open(path, 'wb') as hgrc: | ||
hgrc.write(b'[ui]\n') | ||||
hgrc.write(b'slash = True\n') | ||||
hgrc.write(b'interactive = False\n') | ||||
|
r46430 | hgrc.write(b'detailed-exit-code = True\n') | ||
|
r40506 | hgrc.write(b'merge = internal:merge\n') | ||
|
r35466 | hgrc.write(b'mergemarkers = detailed\n') | ||
hgrc.write(b'promptecho = True\n') | ||||
r46636 | hgrc.write(b'timeout.warn=15\n') | |||
|
r35466 | hgrc.write(b'[defaults]\n') | ||
hgrc.write(b'[devel]\n') | ||||
hgrc.write(b'all-warnings = true\n') | ||||
hgrc.write(b'default-date = 0 0\n') | ||||
hgrc.write(b'[largefiles]\n') | ||||
|
r43346 | hgrc.write( | ||
b'usercache = %s\n' | ||||
% (os.path.join(self._testtmp, b'.cache/largefiles')) | ||||
) | ||||
|
r35466 | hgrc.write(b'[lfs]\n') | ||
|
r43346 | hgrc.write( | ||
b'usercache = %s\n' | ||||
% (os.path.join(self._testtmp, b'.cache/lfs')) | ||||
) | ||||
|
r35466 | hgrc.write(b'[web]\n') | ||
hgrc.write(b'address = localhost\n') | ||||
|
r44933 | hgrc.write(b'ipv6 = %r\n' % self._useipv6) | ||
|
r37027 | hgrc.write(b'server-header = testing stub value\n') | ||
|
r35466 | |||
for opt in self._extraconfigopts: | ||||
|
r44936 | section, key = _sys2bytes(opt).split(b'.', 1) | ||
|
r43346 | assert b'=' in key, ( | ||
'extra config opt %s must ' 'have an = for assignment' % opt | ||||
) | ||||
|
r35466 | hgrc.write(b'[%s]\n%s\n' % (section, key)) | ||
|
r21382 | |||
|
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: | ||
|
r43346 | proc = subprocess.Popen( | ||
|
r44935 | _bytes2sys(cmd), | ||
shell=True, | ||||
cwd=_bytes2sys(self._testtmp), | ||||
env=env, | ||||
|
r43346 | ) | ||
|
r24508 | ret = proc.wait() | ||
return (ret, None) | ||||
|
r24509 | proc = Popen4(cmd, self._testtmp, self._timeout, env) | ||
|
r43346 | |||
|
r24508 | def cleanup(): | ||
terminate(proc) | ||||
ret = proc.wait() | ||||
if ret == 0: | ||||
ret = signal.SIGTERM << 8 | ||||
killdaemons(env['DAEMON_PIDS']) | ||||
return ret | ||||
proc.tochild.close() | ||||
try: | ||||
output = proc.fromchild.read() | ||||
except KeyboardInterrupt: | ||||
vlog('# Handling keyboard interrupt') | ||||
cleanup() | ||||
raise | ||||
ret = proc.wait() | ||||
|
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: | ||||
|
r39742 | output = output.replace(b'\r\n', b'\n') | ||
|
r24510 | |||
|
r24508 | return ret, output.splitlines(True) | ||
|
r43346 | |||
|
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): | ||
|
r40306 | # Quote the python(3) executable for Windows | ||
|
r44602 | cmd = b'"%s" "%s"' % (PYTHON, self.path) | ||
|
r43614 | vlog("# Running", cmd.decode("utf-8")) | ||
r48373 | result = self._runcommand(cmd, env, normalizenewlines=WINDOWS) | |||
|
r21520 | if self._aborted: | ||
raise KeyboardInterrupt() | ||||
return result | ||||
|
r21311 | |||
|
r43346 | |||
|
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]) | ||
r43134 | WARN_UNDEFINED = 1 | |||
WARN_YES = 2 | ||||
WARN_NO = 3 | ||||
r43171 | MARK_OPTIONAL = b" (?)\n" | |||
|
r43346 | |||
r43171 | def isoptional(line): | |||
return line.endswith(MARK_OPTIONAL) | ||||
|
r43346 | |||
|
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 | ||
|
r44937 | ESCAPEMAP = {bchr(i): br'\x%02x' % i for i in range(256)} | ||
|
r25041 | ESCAPEMAP.update({b'\\': b'\\\\', b'\r': br'\r'}) | ||
|
r21381 | |||
|
r32317 | def __init__(self, path, *args, **kwds): | ||
# accept an extra "case" parameter | ||||
|
r38860 | case = kwds.pop('case', []) | ||
|
r32317 | self._case = case | ||
|
r38860 | self._allcases = {x for y in parsettestcases(path) for x in y} | ||
|
r32317 | super(TTest, self).__init__(path, *args, **kwds) | ||
if case: | ||||
|
r38969 | casepath = b'#'.join(case) | ||
|
r44935 | self.name = '%s#%s' % (self.name, _bytes2sys(casepath)) | ||
|
r38860 | self.errpath = b'%s#%s.err' % (self.errpath[:-4], casepath) | ||
|
r45668 | self._tmpname += b'-%s' % casepath.replace(b'#', b'-') | ||
|
r36480 | self._have = {} | ||
|
r32317 | |||
|
r21501 | @property | ||
|
r21521 | def refpath(self): | ||
|
r25041 | return os.path.join(self._testdir, self.bname) | ||
|
r21501 | |||
|
r24516 | def _run(self, env): | ||
|
r35466 | with open(self.path, 'rb') as f: | ||
lines = f.readlines() | ||||
|
r21313 | |||
|
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 | ||
|
r35466 | with open(fname, 'wb') as f: | ||
for l in script: | ||||
f.write(l) | ||||
|
r21313 | |||
|
r25041 | cmd = b'%s "%s"' % (self._shell, fname) | ||
|
r43614 | vlog("# Running", cmd.decode("utf-8")) | ||
|
r21313 | |||
|
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): | ||
|
r36480 | allreqs = b' '.join(reqs) | ||
r41968 | ||||
self._detectslow(reqs) | ||||
|
r36480 | if allreqs in self._have: | ||
return self._have.get(allreqs) | ||||
|
r21312 | # TODO do something smarter when all other uses of hghave are gone. | ||
r44978 | runtestdir = osenvironb[b'RUNTESTDIR'] | |||
|
r25728 | tdir = runtestdir.replace(b'\\', b'/') | ||
|
r43346 | proc = Popen4( | ||
b'%s -c "%s/hghave %s"' % (self._shell, tdir, allreqs), | ||||
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: | ||
|
r36480 | self._have[allreqs] = (False, stdout) | ||
|
r27564 | return False, stdout | ||
|
r27141 | |||
|
r36480 | self._have[allreqs] = (True, None) | ||
|
r27564 | return True, None | ||
|
r21312 | |||
r41967 | def _detectslow(self, reqs): | |||
"""update the timeout of slow test when appropriate""" | ||||
if b'slow' in reqs: | ||||
self._timeout = self._slowtimeout | ||||
|
r32317 | def _iftest(self, args): | ||
# implements "#if" | ||||
reqs = [] | ||||
for arg in args: | ||||
if arg.startswith(b'no-') and arg[3:] in self._allcases: | ||||
|
r38860 | if arg[3:] in self._case: | ||
|
r32317 | return False | ||
elif arg in self._allcases: | ||||
|
r38860 | if arg not in self._case: | ||
|
r32317 | return False | ||
else: | ||||
reqs.append(arg) | ||||
r41969 | self._detectslow(reqs) | |||
|
r32317 | 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() | ||
|
r43346 | |||
|
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)) | ||
|
r43346 | |||
|
r40524 | activetrace = [] | ||
|
r39289 | session = str(uuid.uuid4()) | ||
if PYTHON3: | ||||
session = session.encode('ascii') | ||||
|
r43346 | hgcatapult = os.getenv('HGTESTCATAPULTSERVERPIPE') or os.getenv( | ||
'HGCATAPULTSERVERPIPE' | ||||
) | ||||
|
r40523 | def toggletrace(cmd=None): | ||
if not hgcatapult or hgcatapult == os.devnull: | ||||
return | ||||
|
r40524 | if activetrace: | ||
|
r40523 | script.append( | ||
|
r43346 | b'echo END %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n' | ||
% (session, activetrace[0]) | ||||
) | ||||
|
r40523 | if cmd is None: | ||
return | ||||
|
r39433 | if isinstance(cmd, str): | ||
quoted = shellquote(cmd.strip()) | ||||
else: | ||||
quoted = shellquote(cmd.strip().decode('utf8')).encode('utf8') | ||||
quoted = quoted.replace(b'\\', b'\\\\') | ||||
|
r40523 | script.append( | ||
|
r43346 | b'echo START %s %s >> "$HGTESTCATAPULTSERVERPIPE"\n' | ||
% (session, quoted) | ||||
) | ||||
|
r40524 | activetrace[0:] = [quoted] | ||
|
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') | ||
|
r39289 | |||
|
r39415 | if hgcatapult and hgcatapult != os.devnull: | ||
|
r42725 | if PYTHON3: | ||
hgcatapult = hgcatapult.encode('utf8') | ||||
cataname = self.name.encode('utf8') | ||||
else: | ||||
cataname = self.name | ||||
|
r39289 | # Kludge: use a while loop to keep the pipe from getting | ||
# closed by our echo commands. The still-running file gets | ||||
# reaped at the end of the script, which causes the while | ||||
# loop to exit and closes the pipe. Sigh. | ||||
script.append( | ||||
b'rtendtracing() {\n' | ||||
|
r40525 | b' echo END %(session)s %(name)s >> %(catapult)s\n' | ||
|
r39289 | b' rm -f "$TESTTMP/.still-running"\n' | ||
b'}\n' | ||||
b'trap "rtendtracing" 0\n' | ||||
b'touch "$TESTTMP/.still-running"\n' | ||||
b'while [ -f "$TESTTMP/.still-running" ]; do sleep 1; done ' | ||||
|
r40525 | b'> %(catapult)s &\n' | ||
|
r39289 | b'HGCATAPULTSESSION=%(session)s ; export HGCATAPULTSESSION\n' | ||
|
r40525 | b'echo START %(session)s %(name)s >> %(catapult)s\n' | ||
|
r39289 | % { | ||
|
r42725 | b'name': cataname, | ||
b'session': session, | ||||
b'catapult': hgcatapult, | ||||
|
r39289 | } | ||
) | ||||
|
r35554 | if self._case: | ||
|
r38969 | casestr = b'#'.join(self._case) | ||
|
r44950 | if isinstance(casestr, str): | ||
|
r38860 | quoted = shellquote(casestr) | ||
|
r35841 | else: | ||
|
r38860 | quoted = shellquote(casestr.decode('utf8')).encode('utf8') | ||
|
r35841 | script.append(b'TESTCASE=%s\n' % quoted) | ||
|
r35554 | script.append(b'export TESTCASE\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': | ||
|
r43726 | after.setdefault(pos, []).append( | ||
b' !!! invalid #require\n' | ||||
) | ||||
|
r36695 | if not skipping: | ||
haveresult, message = self._hghave(lsplit[1:]) | ||||
if not haveresult: | ||||
script = [b'echo "%s"\nexit 80\n' % message] | ||||
break | ||||
|
r22045 | 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': | ||
|
r43726 | after.setdefault(pos, []).append(b' !!! invalid #if\n') | ||
|
r21312 | if skipping is not None: | ||
|
r43726 | after.setdefault(pos, []).append(b' !!! 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: | ||
|
r43726 | after.setdefault(pos, []).append(b' !!! missing #if\n') | ||
|
r21312 | skipping = not skipping | ||
after.setdefault(pos, []).append(l) | ||||
|
r25035 | elif l.startswith(b'#endif'): | ||
|
r21312 | if skipping is None: | ||
|
r43726 | after.setdefault(pos, []).append(b' !!! missing #if\n') | ||
|
r21312 | skipping = None | ||
after.setdefault(pos, []).append(l) | ||||
elif skipping: | ||||
after.setdefault(pos, []).append(l) | ||||
|
r43346 | 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 | ||||
|
r43346 | addsalt(prepos, False) # Make sure we report the exit code. | ||
|
r39753 | script.append(b'"%s" -m heredoctest <<EOF\n' % PYTHON) | ||
|
r21312 | addsalt(n, True) | ||
script.append(l[2:]) | ||||
|
r43346 | elif l.startswith(b' ... '): # python inlines | ||
|
r21312 | after.setdefault(prepos, []).append(l) | ||
script.append(l[2:]) | ||||
|
r43346 | 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) | ||||
|
r39289 | rawcmd = l[4:] | ||
cmd = rawcmd.split() | ||||
toggletrace(rawcmd) | ||||
|
r25060 | if len(cmd) == 2 and cmd[0] == b'cd': | ||
|
r44434 | rawcmd = b'cd %s || exit 1\n' % cmd[1] | ||
|
r39289 | script.append(rawcmd) | ||
|
r43346 | elif l.startswith(b' > '): # continuations | ||
|
r21312 | after.setdefault(prepos, []).append(l) | ||
script.append(l[4:]) | ||||
|
r43346 | 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: | ||
|
r43726 | after.setdefault(pos, []).append(b' !!! missing #endif\n') | ||
|
r21312 | addsalt(n + 1, False) | ||
|
r40523 | # Need to end any current per-command trace | ||
|
r40524 | if activetrace: | ||
|
r40523 | toggletrace() | ||
|
r21312 | return salt, script, after, expected | ||
|
r21314 | def _processoutput(self, exitcode, output, salt, after, expected): | ||
# Merge the script output back into a unified test. | ||||
|
r43346 | warnonly = WARN_UNDEFINED # 1: not yet; 2: yes; 3: for sure not | ||
|
r21314 | if exitcode != 0: | ||
r43134 | warnonly = WARN_NO | |||
|
r21314 | |||
pos = -1 | ||||
postout = [] | ||||
r43135 | for out_rawline in output: | |||
r43137 | out_line, cmd_line = out_rawline, None | |||
r43135 | if salt in out_rawline: | |||
r43137 | out_line, cmd_line = out_rawline.split(salt, 1) | |||
r43136 | ||||
|
r43346 | pos, postout, warnonly = self._process_out_line( | ||
out_line, pos, postout, expected, warnonly | ||||
) | ||||
pos, postout = self._process_cmd_line(cmd_line, pos, postout, after) | ||||
|
r21314 | |||
if pos in after: | ||||
postout += after.pop(pos) | ||||
r43169 | if warnonly == WARN_YES: | |||
|
r43346 | exitcode = False # Set exitcode to warned. | ||
|
r21314 | |||
return exitcode, postout | ||||
|
r21312 | |||
r43169 | def _process_out_line(self, out_line, pos, postout, expected, warnonly): | |||
r43170 | while out_line: | |||
if not out_line.endswith(b'\n'): | ||||
out_line += b' (no-eol)\n' | ||||
# Find the expected output at the current position. | ||||
els = [None] | ||||
if expected.get(pos, None): | ||||
els = expected[pos] | ||||
optional = [] | ||||
for i, el in enumerate(els): | ||||
r = False | ||||
if el: | ||||
r, exact = self.linematch(el, out_line) | ||||
if isinstance(r, str): | ||||
if r == '-glob': | ||||
out_line = ''.join(el.rsplit(' (glob)', 1)) | ||||
|
r43346 | r = '' # Warn only this line. | ||
r43170 | elif r == "retry": | |||
postout.append(b' ' + el) | ||||
else: | ||||
log('\ninfo, unknown linematch result: %r\n' % r) | ||||
r = False | ||||
if r: | ||||
els.pop(i) | ||||
break | ||||
if el: | ||||
r43171 | if isoptional(el): | |||
r43170 | optional.append(i) | |||
else: | ||||
m = optline.match(el) | ||||
if m: | ||||
|
r43346 | conditions = [c for c in m.group(2).split(b' ')] | ||
r43170 | ||||
if not self._iftest(conditions): | ||||
optional.append(i) | ||||
if exact: | ||||
# Don't allow line to be matches against a later | ||||
# line in the output | ||||
|
r28569 | els.pop(i) | ||
break | ||||
r43170 | ||||
if r: | ||||
if r == "retry": | ||||
continue | ||||
# clean up any optional leftovers | ||||
for i in optional: | ||||
postout.append(b' ' + els[i]) | ||||
for i in reversed(optional): | ||||
del els[i] | ||||
postout.append(b' ' + el) | ||||
else: | ||||
if self.NEEDESCAPE(out_line): | ||||
|
r43346 | out_line = TTest._stringescape( | ||
b'%s (esc)\n' % out_line.rstrip(b'\n') | ||||
) | ||||
postout.append(b' ' + out_line) # Let diff deal with it. | ||||
if r != '': # If line failed. | ||||
r43170 | warnonly = WARN_NO | |||
elif warnonly == WARN_UNDEFINED: | ||||
warnonly = WARN_YES | ||||
break | ||||
else: | ||||
# clean up any optional leftovers | ||||
while expected.get(pos, None): | ||||
el = expected[pos].pop(0) | ||||
if el: | ||||
r43171 | if not isoptional(el): | |||
r43170 | m = optline.match(el) | |||
if m: | ||||
conditions = [c for c in m.group(2).split(b' ')] | ||||
if self._iftest(conditions): | ||||
# Don't append as optional line | ||||
continue | ||||
|
r31829 | else: | ||
r43170 | continue | |||
postout.append(b' ' + el) | ||||
r43169 | return pos, postout, warnonly | |||
|
r21312 | |||
r43168 | def _process_cmd_line(self, cmd_line, pos, postout, after): | |||
"""process a "command" part of a line from unified test output""" | ||||
if cmd_line: | ||||
# Add on last return code. | ||||
ret = int(cmd_line.split()[1]) | ||||
if ret != 0: | ||||
postout.append(b' [%d]\n' % ret) | ||||
if pos in after: | ||||
# Merge in non-active test bits. | ||||
postout += after.pop(pos) | ||||
pos = int(cmd_line.split()[0]) | ||||
return pos, postout | ||||
|
r21315 | @staticmethod | ||
|
r21316 | def rematch(el, l): | ||
try: | ||||
|
r44240 | # parse any flags at the beginning of the regex. Only 'i' is | ||
# supported right now, but this should be easy to extend. | ||||
flags, el = re.match(br'^(\(\?i\))?(.*)', el).groups()[0:2] | ||||
flags = flags or b'' | ||||
el = flags + b'(?:' + el + b')' | ||||
|
r21316 | # use \Z to ensure that the regex matches to the end of the string | ||
r48373 | if WINDOWS: | |||
|
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: | ||
|
r43346 | c = el[i : i + 1] | ||
|
r21317 | i += 1 | ||
|
r43346 | if c == b'\\' and i < n and el[i : i + 1] in b'*?\\/': | ||
res += el[i - 1 : i + 1] | ||||
|
r21317 | 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): | ||
|
r43346 | if el == l: # perfect match (fast) | ||
|
r38572 | return True, True | ||
|
r38570 | retry = False | ||
r43171 | if isoptional(el): | |||
|
r38570 | retry = "retry" | ||
|
r43346 | el = el[: -len(MARK_OPTIONAL)] + b"\n" | ||
|
r38570 | else: | ||
m = optline.match(el) | ||||
if m: | ||||
conditions = [c for c in m.group(2).split(b' ')] | ||||
el = m.group(1) + b"\n" | ||||
if not self._iftest(conditions): | ||||
r42705 | # listed feature missing, should not match | |||
return "retry", False | ||||
|
r38570 | |||
if el.endswith(b" (esc)\n"): | ||||
if PYTHON3: | ||||
el = el[:-7].decode('unicode_escape') + '\n' | ||||
|
r45552 | el = el.encode('latin-1') | ||
|
r31829 | else: | ||
|
r38570 | el = el[:-7].decode('string-escape') + '\n' | ||
r48373 | if el == l or WINDOWS and el[:-1] + b'\r\n' == l: | |||
|
r38572 | return True, True | ||
|
r38570 | if el.endswith(b" (re)\n"): | ||
|
r38572 | return (TTest.rematch(el[:-6], l) or retry), False | ||
|
r38570 | if el.endswith(b" (glob)\n"): | ||
# ignore '(glob)' added to l by 'replacements' | ||||
if l.endswith(b" (glob)\n"): | ||||
l = l[:-8] + b"\n" | ||||
|
r38572 | return (TTest.globmatch(el[:-8], l) or retry), False | ||
|
r38570 | if os.altsep: | ||
_l = l.replace(b'\\', b'/') | ||||
r48373 | if el == _l or WINDOWS and el[:-1] + b'\r\n' == _l: | |||
|
r38572 | return True, True | ||
return retry, True | ||||
|
r21315 | |||
|
r21379 | @staticmethod | ||
def parsehghaveoutput(lines): | ||||
|
r46554 | """Parse hghave log lines. | ||
|
r21379 | |||
Return tuple of lists (missing, failed): | ||||
* the missing/unknown features | ||||
|
r46554 | * the features for which existence check failed""" | ||
|
r21379 | missing = [] | ||
failed = [] | ||||
for line in lines: | ||||
|
r21381 | if line.startswith(TTest.SKIPPED_PREFIX): | ||
|
r21379 | line = line.splitlines()[0] | ||
|
r44959 | missing.append(_bytes2sys(line[len(TTest.SKIPPED_PREFIX) :])) | ||
|
r21381 | elif line.startswith(TTest.FAILED_PREFIX): | ||
|
r21379 | line = line.splitlines()[0] | ||
|
r44959 | failed.append(_bytes2sys(line[len(TTest.FAILED_PREFIX) :])) | ||
|
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) | ||||
|
r43346 | |||
|
r22104 | iolock = threading.RLock() | ||
|
r35586 | firstlock = threading.RLock() | ||
firsterror = False | ||||
|
r14000 | |||
|
r43346 | |||
|
r21429 | class TestResult(unittest._TextTestResult): | ||
"""Holds results when executing via unittest.""" | ||||
|
r43346 | |||
|
r21429 | # 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': | ||
|
r48090 | isatty = self.stream.isatty() | ||
# For some reason, redirecting stdout on Windows disables the ANSI | ||||
# color processing of stderr, which is what is used to print the | ||||
# output. Therefore, both must be tty on Windows to enable color. | ||||
r48373 | if WINDOWS: | |||
|
r48090 | isatty = isatty and sys.stdout.isatty() | ||
self.color = pygmentspresent and isatty | ||||
|
r33565 | elif options.color == 'never': | ||
self.color = False | ||||
|
r43346 | else: # 'always', for testing purposes | ||
|
r33565 | self.color = pygmentspresent | ||
|
r33561 | |||
|
r38636 | def onStart(self, test): | ||
|
r46554 | """Can be overriden by custom TestResult""" | ||
|
r38636 | |||
def onEnd(self): | ||||
|
r46554 | """Can be overriden by custom TestResult""" | ||
|
r38636 | |||
|
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.""" | ||
|
r35586 | if self.shouldStop or firsterror: | ||
|
r22838 | # 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 | ||
|
r43346 | subprocess.call( | ||
r'"%s" "%s" "%s"' | ||||
|
r44935 | % (v, _bytes2sys(test.refpath), _bytes2sys(test.errpath)), | ||
|
r43346 | shell=True, | ||
) | ||||
|
r21521 | else: | ||
|
r43346 | servefail, lines = getdiff( | ||
expected, got, test.refpath, test.errpath | ||||
) | ||||
|
r36456 | self.stream.write('\n') | ||
for line in lines: | ||||
line = highlightdiff(line, self.color) | ||||
if PYTHON3: | ||||
self.stream.flush() | ||||
self.stream.buffer.write(line) | ||||
self.stream.buffer.flush() | ||||
else: | ||||
self.stream.write(line) | ||||
self.stream.flush() | ||||
|
r21521 | |||
|
r36479 | if servefail: | ||
raise test.failureException( | ||||
|
r43346 | 'server failed to start (HGPORT=%s)' % test._startport | ||
) | ||||
|
r36479 | |||
|
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 ' | ||||
|
r43346 | 'changes)' | ||
) | ||||
|
r32980 | else: | ||
|
r45470 | self.stream.write('Accept this change? [y/N] ') | ||
|
r39945 | self.stream.flush() | ||
|
r32980 | 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: | ||||
r47113 | rename(test.errpath, b'%s.out' % test.path) | |||
|
r32980 | 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 | ||||
|
r43991 | # and not for Windows. Hence why we fall back to another function | ||
# for wall time calculations. | ||||
|
r43990 | test.started_times = os.times() | ||
|
r43991 | # TODO use a monotonic clock once support for Python 2.7 is dropped. | ||
test.started_time = time.time() | ||||
|
r43346 | if self._firststarttime is None: # thread racy but irrelevant | ||
|
r43991 | self._firststarttime = test.started_time | ||
|
r21495 | |||
def stopTest(self, test, interrupted=False): | ||||
super(TestResult, self).stopTest(test) | ||||
|
r43990 | test.stopped_times = os.times() | ||
|
r43991 | stopped_time = time.time() | ||
|
r43990 | |||
starttime = test.started_times | ||||
endtime = test.stopped_times | ||||
|
r25097 | origin = self._firststarttime | ||
|
r43346 | self.times.append( | ||
( | ||||
test.name, | ||||
endtime[2] - starttime[2], # user space CPU time | ||||
endtime[3] - starttime[3], # sys space CPU time | ||||
|
r43991 | stopped_time - test.started_time, # real time | ||
test.started_time - origin, # start date in run context | ||||
stopped_time - origin, # end date in run context | ||||
|
r43346 | ) | ||
) | ||||
|
r21977 | |||
|
r21495 | if interrupted: | ||
|
r25046 | with iolock: | ||
|
r43346 | self.stream.writeln( | ||
'INTERRUPTED: %s (after %d seconds)' | ||||
% (test.name, self.times[-1][3]) | ||||
) | ||||
|
r21495 | |||
|
r38635 | def getTestResult(): | ||
""" | ||||
Returns the relevant test result | ||||
""" | ||||
if "CUSTOM_TEST_RESULT" in os.environ: | ||||
testresultmodule = __import__(os.environ["CUSTOM_TEST_RESULT"]) | ||||
return testresultmodule.TestResult | ||||
else: | ||||
return TestResult | ||||
|
r43346 | |||
|
r21439 | class TestSuite(unittest.TestSuite): | ||
|
r23139 | """Custom unittest TestSuite that knows how to execute Mercurial tests.""" | ||
|
r21528 | |||
|
r43346 | def __init__( | ||
self, | ||||
testdir, | ||||
jobs=1, | ||||
whitelist=None, | ||||
blacklist=None, | ||||
keywords=None, | ||||
loop=False, | ||||
runs_per_test=1, | ||||
loadtest=None, | ||||
showchannels=False, | ||||
*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 | |||
|
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 | ||||
|
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: | ||
|
r43346 | |||
|
r24330 | def get(): | ||
num_tests[0] += 1 | ||||
if getattr(test, 'should_reload', False): | ||||
|
r32310 | return self._loadtest(test, num_tests[0]) | ||
|
r24330 | return test | ||
|
r43346 | |||
|
r21507 | if not os.path.exists(test.path): | ||
result.addSkip(test, "Doesn't exist") | ||||
continue | ||||
|
r46086 | is_whitelisted = self._whitelist and ( | ||
test.relpath in self._whitelist or test.bname in self._whitelist | ||||
) | ||||
if not is_whitelisted: | ||||
is_blacklisted = self._blacklist and ( | ||||
test.relpath in self._blacklist | ||||
or test.bname in self._blacklist | ||||
) | ||||
if is_blacklisted: | ||||
|
r21507 | result.addSkip(test, 'blacklisted') | ||
continue | ||||
|
r21531 | if self._keywords: | ||
|
r35466 | with open(test.path, 'rb') as f: | ||
t = f.read().lower() + test.bname.lower() | ||||
|
r21507 | 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 | ||
|
r43346 | except: # re-raises | ||
|
r21496 | 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: | ||||
|
r43346 | time.sleep(0.1) | ||
|
r27396 | 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 | ||||
|
r43346 | tests.append(self._loadtest(test, num_tests[0])) | ||
|
r27880 | else: | ||
tests.append(test) | ||||
if self._jobs == 1: | ||||
job(test, result) | ||||
else: | ||||
|
r43346 | t = threading.Thread( | ||
target=job, name=test.name, args=(test, result) | ||||
) | ||||
|
r27689 | 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 | ||
|
r43346 | |||
|
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. | ||||
|
r43346 | |||
|
r32717 | def loadtimes(outputdir): | ||
|
r27634 | times = [] | ||
try: | ||||
|
r35873 | with open(os.path.join(outputdir, b'.testtimes')) as fp: | ||
|
r27634 | for line in fp: | ||
|
r35872 | m = re.match('(.*?) ([0-9. ]+)', line) | ||
|
r43346 | times.append( | ||
(m.group(1), [float(t) for t in m.group(2).split()]) | ||||
) | ||||
|
r27634 | except IOError as err: | ||
if err.errno != errno.ENOENT: | ||||
raise | ||||
return times | ||||
|
r43346 | |||
|
r32717 | def savetimes(outputdir, result): | ||
saved = dict(loadtimes(outputdir)) | ||||
|
r27634 | maxruns = 5 | ||
|
r44937 | skipped = {str(t[0]) for t in result.skipped} | ||
|
r27634 | 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:] | ||||
|
r43346 | fd, tmpname = tempfile.mkstemp( | ||
prefix=b'.testtimes', 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 | ||||
|
r43346 | |||
|
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 | ||||
|
r38639 | |||
|
r43346 | self._result = getTestResult()( | ||
self._runner.options, self.stream, self.descriptions, self.verbosity | ||||
) | ||||
|
r21459 | |||
|
r32704 | def listtests(self, test): | ||
test = sorted(test, key=lambda t: t.name) | ||||
|
r38636 | |||
self._result.onStart(test) | ||||
|
r32704 | for t in test: | ||
print(t.name) | ||||
|
r38636 | self._result.addSuccess(t) | ||
|
r32704 | |||
if self._runner.options.xunit: | ||||
with open(self._runner.options.xunit, "wb") as xuf: | ||||
|
r38636 | self._writexunit(self._result, xuf) | ||
|
r32704 | |||
if self._runner.options.json: | ||||
|
r32718 | jsonpath = os.path.join(self._runner._outputdir, b'report.json') | ||
|
r32704 | with open(jsonpath, 'w') as fp: | ||
|
r38636 | self._writejson(self._result, fp) | ||
return self._result | ||||
|
r32704 | |||
|
r21459 | def run(self, test): | ||
|
r38636 | self._result.onStart(test) | ||
test(self._result) | ||||
failed = len(self._result.failures) | ||||
skipped = len(self._result.skipped) | ||||
ignored = len(self._result.ignored) | ||||
|
r21459 | |||
|
r25046 | with iolock: | ||
self.stream.writeln('') | ||||
|
r21459 | |||
|
r25046 | if not self._runner.options.noskips: | ||
|
r43346 | for test, msg in sorted( | ||
self._result.skipped, key=lambda s: s[0].name | ||||
): | ||||
|
r33930 | formatted = 'Skipped %s: %s\n' % (test.name, msg) | ||
|
r38641 | msg = highlightmsg(formatted, self._result.color) | ||
self.stream.write(msg) | ||||
|
r43346 | for test, msg in sorted( | ||
self._result.failures, key=lambda f: f[0].name | ||||
): | ||||
|
r33930 | formatted = 'Failed %s: %s\n' % (test.name, msg) | ||
|
r38636 | self.stream.write(highlightmsg(formatted, self._result.color)) | ||
|
r43346 | for test, msg in sorted( | ||
self._result.errors, key=lambda e: e[0].name | ||||
): | ||||
|
r25046 | 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: | ||
|
r38636 | self._writexunit(self._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: | ||
|
r38636 | self._writejson(self._result, fp) | ||
|
r22391 | |||
|
r25046 | self._runner._checkhglib('Tested') | ||
|
r21459 | |||
|
r38636 | savetimes(self._runner._outputdir, self._result) | ||
|
r28596 | |||
if failed and self._runner.options.known_good_rev: | ||||
|
r38636 | self._bisecttests(t for t, m in self._result.failures) | ||
|
r25046 | self.stream.writeln( | ||
|
r32942 | '# Ran %d tests, %d skipped, %d failed.' | ||
|
r43346 | % (self._result.testsRun, skipped + ignored, failed) | ||
) | ||||
|
r25046 | if failed: | ||
|
r43346 | self.stream.writeln( | ||
'python hash seed: %s' % os.environ['PYTHONHASHSEED'] | ||||
) | ||||
|
r25046 | if self._runner.options.time: | ||
|
r38636 | self.printtimes(self._result.times) | ||
|
r35191 | |||
if self._runner.options.exceptions: | ||||
exceptions = aggregateexceptions( | ||||
|
r43346 | os.path.join(self._runner._outputdir, b'exceptions') | ||
) | ||||
|
r35191 | |||
self.stream.writeln('Exceptions Report:') | ||||
|
r43346 | self.stream.writeln( | ||
'%d total from %d frames' | ||||
% (exceptions['total'], len(exceptions['exceptioncounts'])) | ||||
) | ||||
|
r36054 | combined = exceptions['combined'] | ||
for key in sorted(combined, key=combined.get, reverse=True): | ||||
frame, line, exc = key | ||||
totalcount, testcount, leastcount, leasttest = combined[key] | ||||
|
r43346 | self.stream.writeln( | ||
'%d (%d tests)\t%s: %s (%s - %d total)' | ||||
% ( | ||||
totalcount, | ||||
testcount, | ||||
frame, | ||||
exc, | ||||
leasttest, | ||||
leastcount, | ||||
) | ||||
) | ||||
|
r35191 | |||
|
r32907 | self.stream.flush() | ||
|
r22104 | |||
|
r38636 | return self._result | ||
|
r21613 | |||
|
r34803 | def _bisecttests(self, tests): | ||
bisectcmd = ['hg', 'bisect'] | ||||
bisectrepo = self._runner.options.bisect_repo | ||||
if bisectrepo: | ||||
bisectcmd.extend(['-R', os.path.abspath(bisectrepo)]) | ||||
|
r43346 | |||
|
r34804 | def pread(args): | ||
|
r34805 | env = os.environ.copy() | ||
env['HGPLAIN'] = '1' | ||||
|
r43346 | p = subprocess.Popen( | ||
args, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, env=env | ||||
) | ||||
|
r34804 | data = p.stdout.read() | ||
|
r34803 | p.wait() | ||
|
r34804 | return data | ||
|
r43346 | |||
|
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: | ||||
|
r44935 | opts += ' --with-hg=%s ' % shellquote(_bytes2sys(withhg)) | ||
|
r43346 | rtc = '%s %s %s %s' % (sysexecutable, sys.argv[0], opts, test) | ||
|
r34804 | data = pread(bisectcmd + ['--command', rtc]) | ||
|
r34803 | m = re.search( | ||
|
r43346 | ( | ||
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), | ||||
) | ||||
|
r34803 | if m is None: | ||
self.stream.writeln( | ||||
|
r43346 | 'Failed to identify failure point for %s' % test | ||
) | ||||
|
r34803 | continue | ||
dat = m.groupdict() | ||||
|
r37759 | verb = 'broken' if dat['goodbad'] == b'bad' else 'fixed' | ||
|
r34803 | self.stream.writeln( | ||
|
r43346 | '%s %s by %s (%s)' | ||
% ( | ||||
test, | ||||
verb, | ||||
dat['node'].decode('ascii'), | ||||
dat['summary'].decode('utf8', 'ignore'), | ||||
) | ||||
) | ||||
|
r34803 | |||
|
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' | ||
|
r43346 | 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. | ||
|
r44937 | timesd = {t[0]: t[3] for t in result.times} | ||
|
r32700 | doc = minidom.Document() | ||
s = doc.createElement('testsuite') | ||||
|
r43346 | s.setAttribute('errors', "0") # TODO | ||
|
r32700 | s.setAttribute('failures', str(len(result.failures))) | ||
|
r41687 | s.setAttribute('name', 'run-tests') | ||
|
r43346 | s.setAttribute( | ||
'skipped', str(len(result.skipped) + len(result.ignored)) | ||||
) | ||||
|
r41687 | s.setAttribute('tests', str(result.testsRun)) | ||
|
r32700 | 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 = {} | ||||
|
r43346 | groups = [ | ||
('success', ((tc, None) for tc in result.successes)), | ||||
('failure', result.failures), | ||||
('skip', result.skipped), | ||||
] | ||||
|
r32701 | 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 | ||||
|
r43346 | tres = { | ||
'result': res, | ||||
'time': ('%0.3f' % timesd[tc.name][2]), | ||||
'cuser': ('%0.3f' % timesd[tc.name][0]), | ||||
'csys': ('%0.3f' % timesd[tc.name][1]), | ||||
'start': ('%0.3f' % timesd[tc.name][3]), | ||||
'end': ('%0.3f' % timesd[tc.name][4]), | ||||
'diff': diff, | ||||
} | ||||
|
r32701 | else: | ||
# blacklisted test | ||||
tres = {'result': res} | ||||
outcome[tc.name] = tres | ||||
|
r43346 | jsonout = json.dumps( | ||
outcome, sort_keys=True, indent=4, separators=(',', ': ') | ||||
) | ||||
|
r32701 | outf.writelines(("testreport =", jsonout)) | ||
|
r43346 | |||
|
r36683 | def sorttests(testdescs, previoustimes, shuffle=False): | ||
|
r35505 | """Do an in-place sort of tests.""" | ||
if shuffle: | ||||
random.shuffle(testdescs) | ||||
return | ||||
|
r36683 | if previoustimes: | ||
|
r43346 | |||
|
r36683 | def sortkey(f): | ||
f = f['path'] | ||||
if f in previoustimes: | ||||
# Use most recent time as estimate | ||||
|
r43346 | return -(previoustimes[f][-1]) | ||
|
r36683 | else: | ||
# Default to a rather arbitrary value of 1 second for new tests | ||||
return -1.0 | ||||
|
r43346 | |||
|
r36683 | else: | ||
# keywords for slow tests | ||||
|
r43346 | slow = { | ||
b'svn': 10, | ||||
b'cvs': 10, | ||||
b'hghave': 10, | ||||
b'largefiles-update': 10, | ||||
b'run-tests': 10, | ||||
b'corruption': 10, | ||||
b'race': 10, | ||||
b'i18n': 10, | ||||
b'check': 100, | ||||
b'gendoc': 100, | ||||
b'contrib-perf': 200, | ||||
b'merge-combination': 100, | ||||
} | ||||
|
r36683 | perf = {} | ||
def sortkey(f): | ||||
# run largest tests first, as they tend to take the longest | ||||
f = f['path'] | ||||
|
r35505 | try: | ||
|
r36683 | return perf[f] | ||
except KeyError: | ||||
try: | ||||
val = -os.stat(f).st_size | ||||
except OSError as e: | ||||
if e.errno != errno.ENOENT: | ||||
raise | ||||
perf[f] = -1e9 # file does not exist, tell early | ||||
return -1e9 | ||||
for kw, mul in slow.items(): | ||||
if kw in f: | ||||
val *= mul | ||||
if f.endswith(b'.py'): | ||||
val /= 10.0 | ||||
perf[f] = val / 1000.0 | ||||
return perf[f] | ||||
|
r35505 | |||
testdescs.sort(key=sortkey) | ||||
|
r43346 | |||
|
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 | ||||
r48375 | # a place for run-tests.py to generate executable it needs | |||
self._custom_bin_dir = None | ||||
|
r21534 | self._pythondir = None | ||
r48374 | # True if we had to infer the pythondir from --with-hg | |||
self._pythondir_inferred = False | ||||
|
r21534 | 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) | ||
|
r44935 | tests = [_sys2bytes(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 | ||||
|
r43346 | |||
|
r25107 | 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): | ||
|
r40522 | testdir = getcwdb() | ||
|
r39754 | self._testdir = osenvironb[b'TESTDIR'] = getcwdb() | ||
|
r34963 | # assume all tests in same folder for now | ||
if testdescs: | ||||
pathname = os.path.dirname(testdescs[0]['path']) | ||||
|
r35065 | if pathname: | ||
|
r40522 | testdir = os.path.join(testdir, pathname) | ||
self._testdir = osenvironb[b'TESTDIR'] = testdir | ||||
|
r32716 | if self.options.outputdir: | ||
|
r44935 | self._outputdir = canonpath(_sys2bytes(self.options.outputdir)) | ||
|
r32716 | else: | ||
|
r40522 | self._outputdir = getcwdb() | ||
|
r35096 | if testdescs and pathname: | ||
self._outputdir = os.path.join(self._outputdir, pathname) | ||||
|
r36683 | previoustimes = {} | ||
if self.options.order_by_runtime: | ||||
previoustimes = dict(loadtimes(self._outputdir)) | ||||
sorttests(testdescs, previoustimes, shuffle=self.options.random) | ||||
|
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)) | ||||
|
r45005 | # Rayon (Rust crate for multi-threading) will use all logical CPU cores | ||
# by default, causing thrashing on high-cpu-count systems. | ||||
# Setting its limit to 3 during tests should still let us uncover | ||||
# multi-threading bugs while keeping the thrashing reasonable. | ||||
os.environ.setdefault("RAYON_NUM_THREADS", "3") | ||||
|
r21369 | if self.options.tmpdir: | ||
self.options.keep_tmpdir = True | ||||
|
r44935 | tmpdir = _sys2bytes(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 | ||
os.makedirs(tmpdir) | ||||
else: | ||||
d = None | ||||
r48373 | if WINDOWS: | |||
|
r21369 | # 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 | |||
|
r43346 | self._hgtmp = osenvironb[b'HGTMP'] = os.path.realpath(tmpdir) | ||
|
r21369 | |||
r48375 | self._custom_bin_dir = os.path.join(self._hgtmp, b'custom-bin') | |||
os.makedirs(self._custom_bin_dir) | ||||
|
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) | ||
|
r21368 | |||
|
r35587 | normbin = os.path.normpath(os.path.abspath(whg)) | ||
|
r44935 | normbin = normbin.replace(_sys2bytes(os.sep), b'/') | ||
|
r35587 | |||
# Other Python scripts in the test harness need to | ||||
# `import mercurial`. If `hg` is a Python script, we assume | ||||
# the Mercurial modules are relative to its path and tell the tests | ||||
# to load Python modules from its directory. | ||||
with open(whg, 'rb') as fh: | ||||
initial = fh.read(1024) | ||||
if re.match(b'#!.*python', initial): | ||||
self._pythondir = self._bindir | ||||
# If it looks like our in-repo Rust binary, use the source root. | ||||
# This is a bit hacky. But rhg is still not supported outside the | ||||
# source directory. So until it is, do the simple thing. | ||||
|
r35618 | elif re.search(b'/rust/target/[^/]+/hg', normbin): | ||
|
r35587 | self._pythondir = os.path.dirname(self._testdir) | ||
# Fall back to the legacy behavior. | ||||
else: | ||||
self._pythondir = self._bindir | ||||
r48374 | self._pythondir_inferred = True | |||
|
r35587 | |||
|
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' | ||
|
r25041 | self._pythondir = os.path.join(self._installdir, b"lib", b"python") | ||
|
r21368 | |||
|
r41012 | # Force the use of hg.exe instead of relying on MSYS to recognize hg is | ||
# a python script and feed it to python.exe. Legacy stdio is force | ||||
# enabled by hg.exe, and this is a more realistic way to launch hg | ||||
# anyway. | ||||
r48373 | if WINDOWS and not self._hgcommand.endswith(b'.exe'): | |||
|
r41011 | self._hgcommand += b'.exe' | ||
r48384 | real_hg = os.path.join(self._bindir, self._hgcommand) | |||
osenvironb[b'HGTEST_REAL_HG'] = real_hg | ||||
|
r28620 | # set CHGHG, then replace "hg" command by "chg" | ||
|
r28142 | chgbindir = self._bindir | ||
|
r28143 | if self.options.chg or self.options.with_chg: | ||
r48384 | osenvironb[b'CHGHG'] = real_hg | |||
|
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) | ||||
|
r47457 | # configure fallback and replace "hg" command by "rhg" | ||
|
r47426 | rhgbindir = self._bindir | ||
if self.options.rhg or self.options.with_rhg: | ||||
|
r47458 | # Affects hghave.py | ||
osenvironb[b'RHG_INSTALLED_AS_HG'] = b'1' | ||||
|
r47457 | # Affects configuration. Alternatives would be setting configuration through | ||
# `$HGRCPATH` but some tests override that, or changing `_hgcommand` to include | ||||
# `--config` but that disrupts tests that print command lines and check expected | ||||
# output. | ||||
osenvironb[b'RHG_ON_UNSUPPORTED'] = b'fallback' | ||||
r48384 | osenvironb[b'RHG_FALLBACK_EXECUTABLE'] = real_hg | |||
|
r47426 | if self.options.rhg: | ||
self._hgcommand = b'rhg' | ||||
elif self.options.with_rhg: | ||||
rhgbindir = os.path.dirname(os.path.realpath(self.options.with_rhg)) | ||||
self._hgcommand = os.path.basename(self.options.with_rhg) | ||||
|
r25041 | osenvironb[b"BINDIR"] = self._bindir | ||
|
r25058 | osenvironb[b"PYTHON"] = PYTHON | ||
|
r21368 | |||
|
r44935 | fileb = _sys2bytes(__file__) | ||
|
r25041 | runtestdir = os.path.abspath(os.path.dirname(fileb)) | ||
|
r25729 | osenvironb[b'RUNTESTDIR'] = runtestdir | ||
|
r25159 | if PYTHON3: | ||
|
r44935 | sepb = _sys2bytes(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) | ||||
|
r47426 | if rhgbindir != self._bindir: | ||
path.insert(1, rhgbindir) | ||||
|
r25730 | if self._testdir != runtestdir: | ||
path = [self._testdir] + path | ||||
r48375 | path = [self._custom_bin_dir] + 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" | ||
|
r44973 | if self.options.rust: | ||
os.environ["HGMODULEPOLICY"] = "rust+c" | ||||
if self.options.no_rust: | ||||
current_policy = os.environ.get("HGMODULEPOLICY", "") | ||||
if current_policy.startswith("rust+"): | ||||
os.environ["HGMODULEPOLICY"] = current_policy[len("rust+") :] | ||||
os.environ.pop("HGWITHRUSTEXT", None) | ||||
|
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 | |||
|
r35191 | if self.options.exceptions: | ||
exceptionsdir = os.path.join(self._outputdir, b'exceptions') | ||||
try: | ||||
os.makedirs(exceptionsdir) | ||||
except OSError as e: | ||||
if e.errno != errno.EEXIST: | ||||
raise | ||||
# Remove all existing exception reports. | ||||
for f in os.listdir(exceptionsdir): | ||||
os.unlink(os.path.join(exceptionsdir, f)) | ||||
osenvironb[b'HGEXCEPTIONSDIR'] = exceptionsdir | ||||
logexceptions = os.path.join(self._testdir, b'logexceptions.py') | ||||
self.options.extra_config_opt.append( | ||||
|
r43346 | 'extensions.logexceptions=%s' % logexceptions.decode('utf-8') | ||
) | ||||
|
r35191 | |||
|
r44935 | vlog("# Using TESTDIR", _bytes2sys(self._testdir)) | ||
vlog("# Using RUNTESTDIR", _bytes2sys(osenvironb[b'RUNTESTDIR'])) | ||||
vlog("# Using HGTMP", _bytes2sys(self._hgtmp)) | ||||
|
r21366 | vlog("# Using PATH", os.environ["PATH"]) | ||
|
r43614 | vlog( | ||
|
r46554 | "# Using", | ||
_bytes2sys(IMPL_PATH), | ||||
_bytes2sys(osenvironb[IMPL_PATH]), | ||||
|
r43614 | ) | ||
|
r44935 | vlog("# Writing to directory", _bytes2sys(self._outputdir)) | ||
|
r21366 | |||
try: | ||||
|
r32311 | return self._runtests(testdescs) or 0 | ||
|
r21366 | finally: | ||
|
r43346 | time.sleep(0.1) | ||
|
r21366 | 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: | ||||
|
r43346 | proc = Popen4( | ||
b'hg st --rev "%s" -man0 .' | ||||
|
r44935 | % _sys2bytes(self.options.changed), | ||
|
r43346 | None, | ||
0, | ||||
) | ||||
|
r21363 | 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 | ||||
|
r44473 | testcasepattern = re.compile(br'([\w-]+\.t|py)(?:#([a-zA-Z0-9_\-.#]+))') | ||
|
r32317 | tests = [] | ||
for t in args: | ||||
|
r38860 | case = [] | ||
|
r38224 | |||
|
r43346 | if not ( | ||
os.path.basename(t).startswith(b'test-') | ||||
and (t.endswith(b'.py') or t.endswith(b'.t')) | ||||
): | ||||
|
r38224 | |||
|
r41174 | m = testcasepattern.match(os.path.basename(t)) | ||
|
r38224 | if m is not None: | ||
|
r41177 | t_basename, casestr = m.groups() | ||
|
r41174 | t = os.path.join(os.path.dirname(t), t_basename) | ||
|
r38860 | if casestr: | ||
|
r38969 | case = casestr.split(b'#') | ||
|
r38224 | else: | ||
continue | ||||
|
r32317 | if t.endswith(b'.t'): | ||
# .t file may contain multiple test cases | ||||
|
r38860 | casedimensions = parsettestcases(t) | ||
if casedimensions: | ||||
cases = [] | ||||
|
r43346 | |||
|
r38860 | def addcases(case, casedimensions): | ||
if not casedimensions: | ||||
cases.append(case) | ||||
else: | ||||
for c in casedimensions[0]: | ||||
addcases(case + [c], casedimensions[1:]) | ||||
|
r43346 | |||
|
r38860 | addcases([], casedimensions) | ||
if case and case in cases: | ||||
cases = [case] | ||||
elif case: | ||||
|
r38224 | # Ignore invalid cases | ||
|
r38860 | cases = [] | ||
|
r38224 | else: | ||
|
r38860 | pass | ||
tests += [{'path': t, 'case': c} for c in sorted(cases)] | ||||
|
r32317 | else: | ||
tests.append({'path': t}) | ||||
else: | ||||
tests.append({'path': t}) | ||||
|
r45967 | |||
if self.options.retest: | ||||
retest_args = [] | ||||
for test in tests: | ||||
|
r45968 | errpath = self._geterrpath(test) | ||
|
r45967 | if os.path.exists(errpath): | ||
retest_args.append(test) | ||||
tests = retest_args | ||||
|
r32317 | 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} | ||||
|
r38860 | case = getattr(test, '_case', []) | ||
|
r32317 | 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] | ||
|
r45968 | errpath = self._geterrpath(desc) | ||
|
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)] | ||
|
r41214 | num_tests = len(tests) * self.options.runs_per_test | ||
jobs = min(num_tests, self.options.jobs) | ||||
|
r40280 | |||
|
r21458 | failed = False | ||
|
r25050 | kws = self.options.keywords | ||
|
r25159 | if kws is not None and PYTHON3: | ||
|
r25050 | kws = kws.encode('utf-8') | ||
|
r21458 | |||
|
r43346 | suite = TestSuite( | ||
self._testdir, | ||||
jobs=jobs, | ||||
whitelist=self.options.whitelisted, | ||||
blacklist=self.options.blacklist, | ||||
keywords=kws, | ||||
loop=self.options.loop, | ||||
runs_per_test=self.options.runs_per_test, | ||||
showchannels=self.options.showchannels, | ||||
tests=tests, | ||||
loadtest=_reloadtest, | ||||
) | ||||
|
r21464 | verbosity = 1 | ||
|
r38639 | if self.options.list_tests: | ||
verbosity = 0 | ||||
elif self.options.verbose: | ||||
|
r21464 | verbosity = 2 | ||
runner = TextTestRunner(self, verbosity=verbosity) | ||||
|
r32703 | |||
|
r32704 | if self.options.list_tests: | ||
result = runner.listtests(suite) | ||||
|
r32703 | else: | ||
r48377 | self._usecorrectpython() | |||
|
r32704 | if self._installdir: | ||
self._installhg() | ||||
self._checkhglib("Testing") | ||||
if self.options.chg: | ||||
assert self._installdir | ||||
self._installchg() | ||||
r47488 | if self.options.rhg: | |||
assert self._installdir | ||||
self._installrhg() | ||||
|
r32703 | |||
|
r43346 | log( | ||
'running %d tests using %d parallel processes' | ||||
% (num_tests, jobs) | ||||
) | ||||
|
r40280 | |||
|
r32704 | result = runner.run(suite) | ||
|
r21613 | |||
|
r42578 | if result.failures or result.errors: | ||
|
r21613 | failed = True | ||
|
r21360 | |||
|
r38636 | result.onEnd() | ||
|
r21360 | if self.options.anycoverage: | ||
|
r21378 | self._outputcoverage() | ||
|
r21360 | except KeyboardInterrupt: | ||
failed = True | ||||
|
r25031 | print("\ninterrupted!") | ||
|
r21360 | |||
if failed: | ||||
return 1 | ||||
|
r45968 | def _geterrpath(self, test): | ||
# test['path'] is a relative path | ||||
if 'case' in test: | ||||
# for multiple dimensions test cases | ||||
casestr = b'#'.join(test['case']) | ||||
errpath = b'%s#%s.err' % (test['path'], casestr) | ||||
else: | ||||
errpath = b'%s.err' % test['path'] | ||||
if self.options.outputdir: | ||||
|
r46013 | self._outputdir = canonpath(_sys2bytes(self.options.outputdir)) | ||
errpath = os.path.join(self._outputdir, errpath) | ||||
|
r45968 | return errpath | ||
|
r24967 | def _getport(self, count): | ||
|
r43346 | port = self._ports.get(count) # do we have a cached entry? | ||
|
r24967 | 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 | ||||
|
r40522 | refpath = os.path.join(getcwdb(), path) | ||
|
r25041 | tmpdir = os.path.join(self._hgtmp, b'child%d' % count) | ||
|
r21504 | |||
|
r32317 | # extra keyword parameters. 'case' is used by .t tests | ||
|
r44937 | kwds = {k: testdesc[k] for k in ['case'] if k in testdesc} | ||
|
r32317 | |||
|
r43346 | t = testcls( | ||
refpath, | ||||
self._outputdir, | ||||
tmpdir, | ||||
keeptmpdir=self.options.keep_tmpdir, | ||||
debug=self.options.debug, | ||||
first=self.options.first, | ||||
timeout=self.options.timeout, | ||||
startport=self._getport(count), | ||||
extraconfigopts=self.options.extra_config_opt, | ||||
shell=self.options.shell, | ||||
hgcommand=self._hgcommand, | ||||
usechg=bool(self.options.with_chg or self.options.chg), | ||||
|
r45105 | chgdebug=self.options.chg_debug, | ||
|
r43346 | 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 | ||||
|
r44935 | vlog("# Cleaning up HGTMP", _bytes2sys(self._hgtmp)) | ||
|
r21534 | 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. | ||||
r48291 | if sys.platform == 'win32': | |||
r48294 | pyexe_names = [b'python', b'python.exe'] | |||
elif sys.version_info[0] < 3: | ||||
pyexe_names = [b'python', b'python2'] | ||||
r48291 | else: | |||
r48294 | pyexe_names = [b'python', b'python3'] | |||
|
r39683 | |||
# os.symlink() is a thing with py3 on Windows, but it requires | ||||
# Administrator rights. | ||||
r48373 | if getattr(os, 'symlink', None) and not WINDOWS: | |||
r48288 | msg = "# Making python executable in test path a symlink to '%s'" | |||
msg %= sysexecutable | ||||
vlog(msg) | ||||
r48294 | for pyexename in pyexe_names: | |||
r48375 | mypython = os.path.join(self._custom_bin_dir, pyexename) | |||
|
r21351 | try: | ||
r48292 | if os.readlink(mypython) == sysexecutable: | |||
continue | ||||
os.unlink(mypython) | ||||
|
r25031 | except OSError as err: | ||
r48292 | if err.errno != errno.ENOENT: | |||
|
r21351 | raise | ||
r48292 | if self._findprogram(pyexename) != sysexecutable: | |||
try: | ||||
os.symlink(sysexecutable, mypython) | ||||
self._createdfiles.append(mypython) | ||||
except OSError as err: | ||||
# child processes may race, which is harmless | ||||
if err.errno != errno.EEXIST: | ||||
raise | ||||
|
r21351 | else: | ||
|
r46684 | # Windows doesn't have `python3.exe`, and MSYS cannot understand the | ||
|
r47044 | # reparse point with that name provided by Microsoft. Create a | ||
# simple script on PATH with that name that delegates to the py3 | ||||
# launcher so the shebang lines work. | ||||
|
r46684 | if os.getenv('MSYSTEM'): | ||
r48376 | py3exe_name = os.path.join(self._custom_bin_dir, b'python3') | |||
with open(py3exe_name, 'wb') as f: | ||||
|
r47044 | f.write(b'#!/bin/sh\n') | ||
|
r47953 | f.write(b'py -3.%d "$@"\n' % sys.version_info[1]) | ||
r48376 | ||||
pyexe_name = os.path.join(self._custom_bin_dir, b'python') | ||||
with open(pyexe_name, 'wb') as f: | ||||
r48294 | f.write(b'#!/bin/sh\n') | |||
r48376 | f.write(b'py -%d.%d "$@"\n' % sys.version_info[0:2]) | |||
|
r46684 | |||
|
r42723 | exedir, exename = os.path.split(sysexecutable) | ||
r48294 | for pyexename in pyexe_names: | |||
msg = "# Modifying search path to find %s as %s in '%s'" | ||||
msg %= (exename, pyexename, exedir) | ||||
vlog(msg) | ||||
|
r21351 | path = os.environ['PATH'].split(os.pathsep) | ||
while exedir in path: | ||||
path.remove(exedir) | ||||
|
r46685 | |||
# Binaries installed by pip into the user area like pylint.exe may | ||||
# not be in PATH by default. | ||||
extra_paths = [exedir] | ||||
vi = sys.version_info | ||||
r48290 | appdata = os.environ.get('APPDATA') | |||
if appdata is not None: | ||||
|
r46685 | scripts_dir = os.path.join( | ||
r48290 | appdata, | |||
|
r46685 | 'Python', | ||
'Python%d%d' % (vi[0], vi[1]), | ||||
'Scripts', | ||||
) | ||||
if vi.major == 2: | ||||
scripts_dir = os.path.join( | ||||
r48290 | appdata, | |||
|
r46685 | 'Python', | ||
'Scripts', | ||||
) | ||||
extra_paths.append(scripts_dir) | ||||
os.environ['PATH'] = os.pathsep.join(extra_paths + path) | ||||
r48294 | for pyexename in pyexe_names: | |||
if not self._findprogram(pyexename): | ||||
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 | ||||
r44972 | setup_opts = b"" | |||
|
r24306 | if self.options.pure: | ||
r44972 | setup_opts = b"--pure" | |||
|
r44973 | elif self.options.rust: | ||
setup_opts = b"--rust" | ||||
elif self.options.no_rust: | ||||
setup_opts = b"--no-rust" | ||||
|
r21353 | |||
# Run installer in hg root | ||||
script = os.path.realpath(sys.argv[0]) | ||||
|
r42723 | exe = sysexecutable | ||
|
r25159 | if PYTHON3: | ||
|
r44935 | compiler = _sys2bytes(compiler) | ||
script = _sys2bytes(script) | ||||
exe = _sys2bytes(exe) | ||||
|
r21353 | hgroot = os.path.dirname(os.path.dirname(script)) | ||
|
r24506 | self._hgroot = hgroot | ||
|
r21353 | os.chdir(hgroot) | ||
|
r25044 | nohome = b'--home=""' | ||
r48373 | if WINDOWS: | |||
|
r21353 | # 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'' | ||
|
r43346 | cmd = ( | ||
r44972 | b'"%(exe)s" setup.py %(setup_opts)s clean --all' | |||
|
r43346 | b' build %(compiler)s --build-base="%(base)s"' | ||
b' install --force --prefix="%(prefix)s"' | ||||
b' --install-lib="%(libdir)s"' | ||||
b' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1' | ||||
% { | ||||
b'exe': exe, | ||||
r44972 | b'setup_opts': setup_opts, | |||
|
r43346 | 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 | ||||
|
r43346 | |||
|
r24075 | makedirs(self._pythondir) | ||
makedirs(self._bindir) | ||||
|
r43614 | vlog("# Running", cmd.decode("utf-8")) | ||
|
r44935 | if subprocess.call(_bytes2sys(cmd), shell=True) == 0: | ||
|
r21353 | if not self.options.verbose: | ||
|
r26087 | try: | ||
os.remove(installerrs) | ||||
except OSError as e: | ||||
if e.errno != errno.ENOENT: | ||||
raise | ||||
|
r21353 | else: | ||
|
r35466 | with open(installerrs, 'rb') as f: | ||
for line in f: | ||||
if PYTHON3: | ||||
sys.stdout.buffer.write(line) | ||||
else: | ||||
sys.stdout.write(line) | ||||
|
r21353 | sys.exit(1) | ||
|
r21534 | os.chdir(self._testdir) | ||
|
r21353 | |||
|
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 | ||||
|
r35466 | with open(hgbat, 'rb') as f: | ||
data = f.read() | ||||
|
r41681 | if br'"%~dp0..\python" "%~dp0hg" %*' in data: | ||
|
r43346 | data = data.replace( | ||
br'"%~dp0..\python" "%~dp0hg" %*', | ||||
b'"%~dp0python" "%~dp0hg" %*', | ||||
) | ||||
|
r35466 | with open(hgbat, 'wb') as f: | ||
f.write(data) | ||||
|
r21353 | else: | ||
|
r25031 | print('WARNING: cannot fix hg.bat reference to python.exe') | ||
|
r21353 | |||
if self.options.anycoverage: | ||||
|
r43577 | custom = os.path.join( | ||
osenvironb[b'RUNTESTDIR'], b'sitecustomize.py' | ||||
) | ||||
target = os.path.join(self._pythondir, b'sitecustomize.py') | ||||
|
r21353 | vlog('# Installing coverage trigger to %s' % target) | ||
shutil.copyfile(custom, target) | ||||
|
r43577 | rc = os.path.join(self._testdir, b'.coveragerc') | ||
|
r21353 | vlog('# Installing coverage rc to %s' % rc) | ||
|
r43577 | osenvironb[b'COVERAGE_PROCESS_START'] = rc | ||
covdir = os.path.join(self._installdir, b'..', b'coverage') | ||||
|
r24505 | try: | ||
os.mkdir(covdir) | ||||
|
r25031 | except OSError as e: | ||
|
r24505 | if e.errno != errno.EEXIST: | ||
raise | ||||
|
r43577 | osenvironb[b'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.""" | ||||
r48374 | if self._pythondir_inferred: | |||
|
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): | ||
|
r43346 | 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 | ||||
|
r40966 | cmd = b'"%s" -c "import mercurial; print (mercurial.__path__[0])"' | ||
|
r25058 | cmd = cmd % PYTHON | ||
|
r25159 | if PYTHON3: | ||
|
r44935 | cmd = _bytes2sys(cmd) | ||
|
r40966 | |||
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True) | ||||
out, err = p.communicate() | ||||
self._hgpath = out.strip() | ||||
|
r21385 | |||
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()' | ||||
|
r43346 | cmd = b'"%(make)s" clean install PREFIX="%(prefix)s"' % { | ||
b'make': b'make', # TODO: switch by option or environment? | ||||
b'prefix': self._installdir, | ||||
} | ||||
|
r28143 | cwd = os.path.join(self._hgroot, b'contrib', b'chg') | ||
vlog("# Running", cmd) | ||||
|
r43346 | proc = subprocess.Popen( | ||
cmd, | ||||
shell=True, | ||||
cwd=cwd, | ||||
stdin=subprocess.PIPE, | ||||
stdout=subprocess.PIPE, | ||||
stderr=subprocess.STDOUT, | ||||
) | ||||
|
r28143 | out, _err = proc.communicate() | ||
if proc.returncode != 0: | ||||
if PYTHON3: | ||||
sys.stdout.buffer.write(out) | ||||
else: | ||||
sys.stdout.write(out) | ||||
sys.exit(1) | ||||
r47488 | def _installrhg(self): | |||
"""Install rhg into the test environment""" | ||||
vlog('# Performing temporary installation of rhg') | ||||
assert os.path.dirname(self._bindir) == self._installdir | ||||
assert self._hgroot, 'must be called after _installhg()' | ||||
cmd = b'"%(make)s" install-rhg PREFIX="%(prefix)s"' % { | ||||
b'make': b'make', # TODO: switch by option or environment? | ||||
b'prefix': self._installdir, | ||||
} | ||||
cwd = self._hgroot | ||||
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 | ||
|
r43346 | |||
|
r29485 | 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) | ||
|
r44935 | covdir = os.path.join(_bytes2sys(self._installdir), '..', 'coverage') | ||
|
r24505 | cov = coverage(data_file=os.path.join(covdir, 'cov')) | ||
|
r24506 | |||
# Map install directory paths back to source directory. | ||||
|
r44935 | cov.config.paths['srcdir'] = ['.', _bytes2sys(self._pythondir)] | ||
|
r24506 | |||
|
r24505 | cov.combine() | ||
|
r21356 | |||
|
r43577 | omit = [ | ||
|
r44935 | _bytes2sys(os.path.join(x, b'*')) | ||
|
r43577 | for x in [self._bindir, self._testdir] | ||
] | ||||
|
r24504 | cov.report(ignore_errors=True, omit=omit) | ||
|
r21356 | if self.options.htmlcov: | ||
|
r44935 | htmldir = os.path.join(_bytes2sys(self._outputdir), 'htmlcov') | ||
|
r24504 | cov.html_report(directory=htmldir, omit=omit) | ||
|
r21356 | if self.options.annotate: | ||
|
r44935 | adir = os.path.join(_bytes2sys(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""" | ||||
|
r44935 | dpb = _sys2bytes(os.defpath) | ||
sepb = _sys2bytes(os.pathsep) | ||||
|
r25038 | for p in osenvironb.get(b'PATH', dpb).split(sepb): | ||
|
r21365 | name = os.path.join(p, program) | ||
r48373 | if WINDOWS or os.access(name, os.X_OK): | |||
|
r45573 | return _bytes2sys(name) | ||
|
r21365 | return None | ||
|
r21374 | def _checktools(self): | ||
|
r21536 | """Ensure tools required to run tests are present.""" | ||
|
r21365 | for p in self.REQUIREDTOOLS: | ||
r48373 | if WINDOWS and not p.endswith(b'.exe'): | |||
|
r39625 | p += b'.exe' | ||
|
r21365 | found = self._findprogram(p) | ||
|
r43614 | p = p.decode("utf-8") | ||
|
r21365 | if found: | ||
|
r45573 | vlog("# Found prerequisite", p, "at", found) | ||
|
r21365 | else: | ||
|
r43614 | print("WARNING: Did not find prerequisite tool: %s " % p) | ||
|
r43346 | |||
|
r21365 | |||
|
r35191 | def aggregateexceptions(path): | ||
|
r36054 | exceptioncounts = collections.Counter() | ||
testsbyfailure = collections.defaultdict(set) | ||||
failuresbytest = collections.defaultdict(set) | ||||
|
r35191 | |||
for f in os.listdir(path): | ||||
with open(os.path.join(path, f), 'rb') as fh: | ||||
data = fh.read().split(b'\0') | ||||
|
r36054 | if len(data) != 5: | ||
|
r35191 | continue | ||
|
r36054 | exc, mainframe, hgframe, hgline, testname = data | ||
|
r35191 | exc = exc.decode('utf-8') | ||
mainframe = mainframe.decode('utf-8') | ||||
hgframe = hgframe.decode('utf-8') | ||||
hgline = hgline.decode('utf-8') | ||||
|
r36054 | testname = testname.decode('utf-8') | ||
key = (hgframe, hgline, exc) | ||||
exceptioncounts[key] += 1 | ||||
testsbyfailure[key].add(testname) | ||||
failuresbytest[testname].add(key) | ||||
# Find test having fewest failures for each failure. | ||||
leastfailing = {} | ||||
for key, tests in testsbyfailure.items(): | ||||
fewesttest = None | ||||
fewestcount = 99999999 | ||||
for test in sorted(tests): | ||||
if len(failuresbytest[test]) < fewestcount: | ||||
fewesttest = test | ||||
fewestcount = len(failuresbytest[test]) | ||||
leastfailing[key] = (fewestcount, fewesttest) | ||||
# Create a combined counter so we can sort by total occurrences and | ||||
# impacted tests. | ||||
combined = {} | ||||
for key in exceptioncounts: | ||||
|
r43346 | combined[key] = ( | ||
exceptioncounts[key], | ||||
len(testsbyfailure[key]), | ||||
leastfailing[key][0], | ||||
leastfailing[key][1], | ||||
) | ||||
|
r36054 | |||
return { | ||||
'exceptioncounts': exceptioncounts, | ||||
'total': sum(exceptioncounts.values()), | ||||
'combined': combined, | ||||
'leastfailing': leastfailing, | ||||
'byfailure': testsbyfailure, | ||||
'bytest': failuresbytest, | ||||
} | ||||
|
r35191 | |||
|
r43346 | |||
|
r13347 | if __name__ == '__main__': | ||
|
r21377 | runner = TestRunner() | ||
|
r22120 | |||
try: | ||||
import msvcrt | ||||
|
r43346 | |||
|
r22120 | 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:])) | ||