run-tests.py
1976 lines
| 70.6 KiB
| text/x-python
|
PythonLexer
/ tests / run-tests.py
|
r2110 | #!/usr/bin/env python | ||
# | ||||
# run-tests.py - Run a set of tests on Mercurial | ||||
# | ||||
# Copyright 2006 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r2110 | |||
|
r8674 | # Modifying this script is tricky because it has many modes: | ||
# - serial (default) vs parallel (-jN, N > 1) | ||||
# - no coverage (default) vs coverage (-c, -C, -s) | ||||
# - temp install (default) vs specific hg script (--with-hg, --local) | ||||
# - tests are a mix of shell scripts and Python scripts | ||||
# | ||||
# If you change this script, it is recommended that you ensure you | ||||
# haven't broken it by running it in various modes with a representative | ||||
# sample of test scripts. For example: | ||||
|
r8843 | # | ||
|
r8674 | # 1) serial, no coverage, temp install: | ||
# ./run-tests.py test-s* | ||||
# 2) serial, no coverage, local hg: | ||||
# ./run-tests.py --local test-s* | ||||
# 3) serial, coverage, temp install: | ||||
# ./run-tests.py -c test-s* | ||||
# 4) serial, coverage, local hg: | ||||
# ./run-tests.py -c --local test-s* # unsupported | ||||
# 5) parallel, no coverage, temp install: | ||||
# ./run-tests.py -j2 test-s* | ||||
# 6) parallel, no coverage, local hg: | ||||
# ./run-tests.py -j2 --local test-s* | ||||
# 7) parallel, coverage, temp install: | ||||
# ./run-tests.py -j2 -c test-s* # currently broken | ||||
|
r9899 | # 8) parallel, coverage, local install: | ||
|
r8674 | # ./run-tests.py -j2 -c --local test-s* # unsupported (and broken) | ||
|
r9899 | # 9) parallel, custom tmp dir: | ||
# ./run-tests.py -j2 --tmpdir /tmp/myhgtests | ||||
|
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.) | ||||
|
r10648 | from distutils import version | ||
|
r2571 | import difflib | ||
import errno | ||||
import optparse | ||||
import os | ||||
|
r10905 | import shutil | ||
|
r8280 | import subprocess | ||
|
r2571 | import signal | ||
import sys | ||||
|
r2110 | import tempfile | ||
|
r2571 | import time | ||
|
r18616 | import random | ||
|
r11741 | import re | ||
|
r14000 | import threading | ||
|
r17464 | import killdaemons as killmod | ||
|
r18057 | import Queue as queue | ||
|
r22044 | from xml.dom import minidom | ||
|
r21426 | import unittest | ||
|
r2110 | |||
|
r22391 | try: | ||
|
r23263 | import json | ||
except ImportError: | ||||
try: | ||||
|
r22391 | import simplejson as json | ||
|
r23263 | except ImportError: | ||
json = None | ||||
|
r22391 | |||
|
r14019 | processlock = threading.Lock() | ||
|
r19413 | |||
|
r19415 | # subprocess._cleanup can race with any Popen.wait or Popen.poll on py24 | ||
# http://bugs.python.org/issue1731717 for details. We shouldn't be producing | ||||
# zombies but it's pretty harmless even if we do. | ||||
|
r20219 | if sys.version_info < (2, 5): | ||
|
r19415 | subprocess._cleanup = lambda: None | ||
|
r14019 | |||
|
r8280 | closefds = os.name == 'posix' | ||
|
r19262 | def Popen4(cmd, wd, timeout, env=None): | ||
|
r14019 | processlock.acquire() | ||
|
r19262 | p = subprocess.Popen(cmd, shell=True, bufsize=-1, cwd=wd, env=env, | ||
|
r8280 | close_fds=closefds, | ||
stdin=subprocess.PIPE, stdout=subprocess.PIPE, | ||||
stderr=subprocess.STDOUT) | ||||
|
r14019 | processlock.release() | ||
|
r8280 | p.fromchild = p.stdout | ||
p.tochild = p.stdin | ||||
p.childerr = p.stderr | ||||
|
r14001 | |||
|
r14337 | p.timeout = False | ||
|
r14001 | if timeout: | ||
def t(): | ||||
start = time.time() | ||||
while time.time() - start < timeout and p.returncode is None: | ||||
|
r16346 | time.sleep(.1) | ||
|
r14001 | p.timeout = True | ||
if p.returncode is None: | ||||
|
r14821 | terminate(p) | ||
|
r14001 | threading.Thread(target=t).start() | ||
|
r8280 | return p | ||
|
r15448 | PYTHON = sys.executable.replace('\\', '/') | ||
|
r10758 | IMPL_PATH = 'PYTHONPATH' | ||
if 'java' in sys.platform: | ||||
IMPL_PATH = 'JYTHONPATH' | ||||
|
r4881 | |||
|
r6366 | defaults = { | ||
'jobs': ('HGTEST_JOBS', 1), | ||||
'timeout': ('HGTEST_TIMEOUT', 180), | ||||
'port': ('HGTEST_PORT', 20059), | ||||
|
r15941 | 'shell': ('HGTEST_SHELL', 'sh'), | ||
|
r6366 | } | ||
|
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") | ||
|
r14493 | except IOError, err: | ||
if err.errno != errno.ENOENT: | ||||
raise | ||||
if warn: | ||||
print "warning: no such %s file: %s" % (listtype, filename) | ||||
continue | ||||
for line in f.readlines(): | ||||
line = line.split('#', 1)[0].strip() | ||||
if line: | ||||
entries[line] = filename | ||||
f.close() | ||||
return entries | ||||
|
r21008 | def getparser(): | ||
|
r21383 | """Obtain the OptionParser used by the CLI.""" | ||
|
r8091 | parser = optparse.OptionParser("%prog [options] [tests]") | ||
|
r11039 | |||
# keep these sorted | ||||
parser.add_option("--blacklist", action="append", | ||||
help="skip tests listed in the specified blacklist file") | ||||
|
r14493 | parser.add_option("--whitelist", action="append", | ||
help="always run tests listed in the specified whitelist file") | ||||
|
r20821 | parser.add_option("--changed", type="string", | ||
help="run tests that are changed in parent rev or working directory") | ||||
|
r8091 | parser.add_option("-C", "--annotate", action="store_true", | ||
help="output files annotated with coverage") | ||||
parser.add_option("-c", "--cover", action="store_true", | ||||
help="print a test coverage report") | ||||
|
r11039 | parser.add_option("-d", "--debug", action="store_true", | ||
help="debug mode: write output of test scripts to console" | ||||
|
r21024 | " rather than capturing and diffing it (disables timeout)") | ||
|
r8091 | parser.add_option("-f", "--first", action="store_true", | ||
help="exit on the first test failure") | ||||
|
r15859 | parser.add_option("-H", "--htmlcov", action="store_true", | ||
help="create an HTML report of the coverage of the files") | ||||
|
r8091 | parser.add_option("-i", "--interactive", action="store_true", | ||
help="prompt to accept changed output") | ||||
parser.add_option("-j", "--jobs", type="int", | ||||
help="number of jobs to run in parallel" | ||||
" (default: $%s or %d)" % defaults['jobs']) | ||||
parser.add_option("--keep-tmpdir", action="store_true", | ||||
|
r9706 | help="keep temporary directory after running tests") | ||
|
r11039 | parser.add_option("-k", "--keywords", | ||
help="run tests matching keywords") | ||||
parser.add_option("-l", "--local", action="store_true", | ||||
help="shortcut for --with-hg=<testdir>/../hg") | ||||
|
r19283 | parser.add_option("--loop", action="store_true", | ||
help="loop tests repeatedly") | ||||
|
r11039 | parser.add_option("-n", "--nodiff", action="store_true", | ||
help="skip showing test changes") | ||||
|
r8091 | parser.add_option("-p", "--port", type="int", | ||
help="port on which servers should listen" | ||||
" (default: $%s or %d)" % defaults['port']) | ||||
|
r17966 | parser.add_option("--compiler", type="string", | ||
help="compiler to build with") | ||||
|
r11039 | parser.add_option("--pure", action="store_true", | ||
help="use pure Python code instead of C extensions") | ||||
parser.add_option("-R", "--restart", action="store_true", | ||||
help="restart at last error") | ||||
|
r8091 | parser.add_option("-r", "--retest", action="store_true", | ||
help="retest failed tests") | ||||
|
r9580 | parser.add_option("-S", "--noskips", action="store_true", | ||
help="don't report skip tests verbosely") | ||||
|
r14202 | parser.add_option("--shell", type="string", | ||
help="shell to use (default: $%s or %s)" % defaults['shell']) | ||||
|
r8091 | parser.add_option("-t", "--timeout", type="int", | ||
help="kill errant tests after TIMEOUT seconds" | ||||
" (default: $%s or %d)" % defaults['timeout']) | ||||
|
r17921 | parser.add_option("--time", action="store_true", | ||
help="time how long each test takes") | ||||
|
r22391 | parser.add_option("--json", action="store_true", | ||
help="store test result data in 'report.json' file") | ||||
|
r11039 | parser.add_option("--tmpdir", type="string", | ||
help="run tests in the given temporary directory" | ||||
" (implies --keep-tmpdir)") | ||||
|
r8091 | parser.add_option("-v", "--verbose", action="store_true", | ||
help="output verbose messages") | ||||
|
r22044 | parser.add_option("--xunit", type="string", | ||
help="record xunit results at specified path") | ||||
|
r11040 | parser.add_option("--view", type="string", | ||
help="external diff viewer") | ||||
|
r8091 | parser.add_option("--with-hg", type="string", | ||
|
r8674 | metavar="HG", | ||
help="test using specified hg script rather than a " | ||||
"temporary installation") | ||||
|
r9028 | parser.add_option("-3", "--py3k-warnings", action="store_true", | ||
help="enable Py3k warnings on Python 2.6+") | ||||
|
r14134 | parser.add_option('--extra-config-opt', action="append", | ||
help='set the given config opt in the test hgrc') | ||||
|
r19057 | parser.add_option('--random', action="store_true", | ||
help='run tests in random order') | ||||
|
r2110 | |||
|
r14201 | for option, (envvar, default) in defaults.items(): | ||
defaults[option] = type(default)(os.environ.get(envvar, default)) | ||||
|
r8091 | parser.set_defaults(**defaults) | ||
|
r21008 | |||
return parser | ||||
def parseargs(args, parser): | ||||
|
r21383 | """Parse arguments with our OptionParser and validate results.""" | ||
|
r21006 | (options, args) = parser.parse_args(args) | ||
|
r8091 | |||
|
r10758 | # jython is always pure | ||
|
r10766 | if 'java' in sys.platform or '__pypy__' in sys.modules: | ||
|
r10765 | options.pure = True | ||
|
r10758 | |||
|
r8674 | if options.with_hg: | ||
|
r15942 | options.with_hg = os.path.expanduser(options.with_hg) | ||
|
r8674 | if not (os.path.isfile(options.with_hg) and | ||
os.access(options.with_hg, os.X_OK)): | ||||
parser.error('--with-hg must specify an executable hg script') | ||||
if not os.path.basename(options.with_hg) == 'hg': | ||||
|
r14359 | sys.stderr.write('warning: --with-hg should specify an hg script\n') | ||
|
r8674 | if options.local: | ||
testdir = os.path.dirname(os.path.realpath(sys.argv[0])) | ||||
hgbin = os.path.join(os.path.dirname(testdir), 'hg') | ||||
|
r16538 | if os.name != 'nt' and not os.access(hgbin, os.X_OK): | ||
|
r8674 | parser.error('--local specified, but %r not found or not executable' | ||
% hgbin) | ||||
options.with_hg = hgbin | ||||
|
r15859 | options.anycoverage = options.cover or options.annotate or options.htmlcov | ||
|
r10648 | if options.anycoverage: | ||
try: | ||||
import coverage | ||||
covver = version.StrictVersion(coverage.__version__).version | ||||
if covver < (3, 3): | ||||
parser.error('coverage options require coverage 3.3 or later') | ||||
except ImportError: | ||||
parser.error('coverage options now require the coverage package') | ||||
|
r8095 | |||
|
r10648 | if options.anycoverage and options.local: | ||
# this needs some path mangling somewhere, I guess | ||||
parser.error("sorry, coverage options do not work when --local " | ||||
"is specified") | ||||
|
r8674 | |||
|
r19250 | global verbose | ||
|
r8095 | if options.verbose: | ||
|
r19279 | verbose = '' | ||
|
r8091 | |||
|
r9394 | if options.tmpdir: | ||
options.tmpdir = os.path.expanduser(options.tmpdir) | ||||
|
r8091 | if options.jobs < 1: | ||
|
r9408 | parser.error('--jobs must be positive') | ||
|
r9707 | if options.interactive and options.debug: | ||
parser.error("-i/--interactive and -d/--debug are incompatible") | ||||
if options.debug: | ||||
if options.timeout != defaults['timeout']: | ||||
sys.stderr.write( | ||||
'warning: --timeout option ignored with --debug\n') | ||||
options.timeout = 0 | ||||
|
r9028 | if options.py3k_warnings: | ||
if sys.version_info[:2] < (2, 6) or sys.version_info[:2] >= (3, 0): | ||||
|
r9408 | parser.error('--py3k-warnings can only be used on Python 2.6+') | ||
|
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 | |||
return (options, args) | ||||
|
r5384 | |||
|
r5800 | def rename(src, dst): | ||
"""Like os.rename(), trade atomicity and opened files friendliness | ||||
for existing destination support. | ||||
""" | ||||
shutil.copy(src, dst) | ||||
os.remove(src) | ||||
|
r21521 | def getdiff(expected, output, ref, err): | ||
|
r21022 | servefail = False | ||
|
r21521 | lines = [] | ||
|
r10088 | for line in difflib.unified_diff(expected, output, ref, err): | ||
|
r21737 | if line.startswith('+++') or line.startswith('---'): | ||
|
r23077 | line = line.replace('\\', '/') | ||
|
r21737 | if line.endswith(' \n'): | ||
line = line[:-2] + '\n' | ||||
|
r21521 | lines.append(line) | ||
|
r21022 | if not servefail and line.startswith( | ||
'+ abort: child process failed to start'): | ||||
servefail = True | ||||
|
r21521 | return servefail, lines | ||
|
r2110 | |||
|
r19250 | verbose = False | ||
def vlog(*msg): | ||||
|
r21535 | """Log only when in verbose mode.""" | ||
if verbose is False: | ||||
return | ||||
return log(*msg) | ||||
|
r19250 | |||
|
r22044 | # Bytes that break XML even in a CDATA block: control characters 0-31 | ||
# sans \t, \n and \r | ||||
CDATA_EVIL = re.compile(r"[\000-\010\013\014\016-\037]") | ||||
def cdatasafe(data): | ||||
"""Make a string safe to include in a CDATA block. | ||||
Certain control characters are illegal in a CDATA block, and | ||||
there's no way to include a ]]> in a CDATA either. This function | ||||
replaces illegal bytes with ? and adds a space between the ]] so | ||||
that it won't break the CDATA block. | ||||
""" | ||||
return CDATA_EVIL.sub('?', data).replace(']]>', '] ]>') | ||||
|
r19251 | def log(*msg): | ||
|
r21535 | """Log something to stdout. | ||
Arguments are strings to print. | ||||
""" | ||||
|
r19251 | iolock.acquire() | ||
if verbose: | ||||
print verbose, | ||||
for m in msg: | ||||
print m, | ||||
sys.stdout.flush() | ||||
iolock.release() | ||||
|
r14821 | def terminate(proc): | ||
"""Terminate subprocess (with fallback for Python versions < 2.6)""" | ||||
vlog('# Terminating process %d' % proc.pid) | ||||
try: | ||||
|
r14971 | getattr(proc, 'terminate', lambda : os.kill(proc.pid, signal.SIGTERM))() | ||
|
r14821 | except OSError: | ||
pass | ||||
|
r19263 | def killdaemons(pidfile): | ||
return killmod.killdaemons(pidfile, tryhard=False, remove=True, | ||||
|
r17464 | logfn=vlog) | ||
|
r10336 | |||
|
r21488 | class Test(unittest.TestCase): | ||
|
r21309 | """Encapsulates a single, runnable test. | ||
|
r21497 | While this class conforms to the unittest.TestCase API, it differs in that | ||
instances need to be instantiated manually. (Typically, unittest.TestCase | ||||
classes are instantiated automatically by scanning modules.) | ||||
|
r21309 | """ | ||
|
r21296 | |||
|
r21380 | # Status code reserved for skipped tests (used by hghave). | ||
SKIPPED_STATUS = 80 | ||||
|
r21520 | def __init__(self, path, tmpdir, keeptmpdir=False, | ||
|
r21521 | debug=False, | ||
|
r21523 | timeout=defaults['timeout'], | ||
|
r21516 | startport=defaults['port'], extraconfigopts=None, | ||
|
r21517 | py3kwarnings=False, shell=None): | ||
|
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 | ||
debug is True. | ||||
|
r21514 | |||
startport controls the starting port number to use for this test. Each | ||||
test will reserve 3 port numbers for execution. It is the caller's | ||||
responsibility to allocate a non-overlapping port range to Test | ||||
instances. | ||||
|
r21515 | |||
extraconfigopts is an iterable of extra hgrc config options. Values | ||||
must have the form "key=value" (something understood by hgrc). Values | ||||
of the form "foo.key=value" will result in "[foo] key=value". | ||||
|
r21516 | |||
py3kwarnings enables Py3k warnings. | ||||
|
r21517 | |||
shell is the shell to execute tests in. | ||||
|
r21502 | """ | ||
|
r21507 | self.path = path | ||
|
r21502 | self.name = os.path.basename(path) | ||
self._testdir = os.path.dirname(path) | ||||
|
r21507 | self.errpath = os.path.join(self._testdir, '%s.err' % self.name) | ||
|
r21435 | |||
|
r21504 | self._threadtmp = tmpdir | ||
|
r21509 | self._keeptmpdir = keeptmpdir | ||
|
r21510 | self._debug = debug | ||
|
r21513 | self._timeout = timeout | ||
|
r21514 | self._startport = startport | ||
|
r21515 | self._extraconfigopts = extraconfigopts or [] | ||
|
r21516 | self._py3kwarnings = py3kwarnings | ||
|
r21517 | self._shell = shell | ||
|
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 | ||
|
r21447 | |||
|
r21318 | # If we're not in --debug mode and reference output file exists, | ||
# check test output against it. | ||||
|
r21510 | if debug: | ||
|
r21318 | self._refout = None # to match "out is None" | ||
|
r21521 | elif os.path.exists(self.refpath): | ||
|
r21916 | f = open(self.refpath, 'rb') | ||
|
r21318 | self._refout = f.read().splitlines(True) | ||
f.close() | ||||
else: | ||||
self._refout = [] | ||||
|
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) | ||||
except OSError, e: | ||||
if e.errno != errno.EEXIST: | ||||
raise | ||||
|
r21454 | self._testtmp = os.path.join(self._threadtmp, | ||
|
r21507 | os.path.basename(self.path)) | ||
|
r21454 | os.mkdir(self._testtmp) | ||
|
r21457 | # Remove any previous output files. | ||
|
r21507 | if os.path.exists(self.errpath): | ||
os.remove(self.errpath) | ||||
|
r21457 | |||
|
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 | ||
except SkipTest, e: | ||||
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 | ||||
|
r21488 | except IgnoreTest, e: | ||
result.addIgnore(self, str(e)) | ||||
|
r21997 | # As with skips, ignores also should be excluded from | ||
# the number of tests executed. | ||||
result.testsRun -= 1 | ||||
|
r21488 | except WarnTest, e: | ||
result.addWarn(self, str(e)) | ||||
except self.failureException, e: | ||||
# 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 | replacements = self._getreplacements() | ||
env = self._getenv() | ||||
|
r21319 | self._daemonpids.append(env['DAEMON_PIDS']) | ||
|
r21382 | self._createhgrc(env['HGRCPATH']) | ||
|
r21300 | |||
|
r21435 | vlog('# Test', self.name) | ||
|
r21337 | |||
|
r21500 | ret, out = self._run(replacements, env) | ||
self._finished = True | ||||
self._ret = ret | ||||
self._out = out | ||||
|
r21305 | |||
|
r21326 | def describe(ret): | ||
if ret < 0: | ||||
return 'killed by signal: %d' % -ret | ||||
return 'returned error code %d' % ret | ||||
|
r21453 | self._skipped = False | ||
|
r21336 | |||
|
r21380 | if ret == self.SKIPPED_STATUS: | ||
|
r21324 | if out is None: # Debug mode, nothing to parse. | ||
missing = ['unknown'] | ||||
failed = None | ||||
else: | ||||
|
r21379 | missing, failed = TTest.parsehghaveoutput(out) | ||
|
r21324 | |||
if not missing: | ||||
|
r22292 | missing = ['skipped'] | ||
|
r21324 | |||
if failed: | ||||
|
r21523 | self.fail('hg have failed checking for %s' % failed[-1]) | ||
|
r21324 | else: | ||
|
r21453 | self._skipped = True | ||
|
r21490 | raise SkipTest(missing[-1]) | ||
|
r21325 | elif ret == 'timeout': | ||
|
r21523 | self.fail('timed out') | ||
|
r21522 | elif ret is False: | ||
raise WarnTest('no result code from test') | ||||
|
r21326 | elif out != self._refout: | ||
|
r21614 | # Diff generation may rely on written .err file. | ||
if (ret != 0 or out != self._refout) and not self._skipped \ | ||||
and not self._debug: | ||||
f = open(self.errpath, 'wb') | ||||
for line in out: | ||||
f.write(line) | ||||
f.close() | ||||
|
r21521 | # The result object handles diff calculation for us. | ||
|
r21763 | if self._result.addOutputMismatch(self, ret, out, self._refout): | ||
# change was accepted, skip failing | ||||
return | ||||
|
r21521 | |||
|
r21326 | if ret: | ||
|
r21521 | msg = 'output changed and ' + describe(ret) | ||
|
r21326 | else: | ||
|
r21521 | msg = 'output changed' | ||
|
r21326 | |||
|
r21523 | self.fail(msg) | ||
|
r21327 | elif ret: | ||
|
r21523 | self.fail(describe(ret)) | ||
|
r21324 | |||
|
r21446 | def tearDown(self): | ||
"""Tasks to perform after run().""" | ||||
|
r21456 | for entry in self._daemonpids: | ||
killdaemons(entry) | ||||
self._daemonpids = [] | ||||
|
r21509 | if not self._keeptmpdir: | ||
|
r21461 | shutil.rmtree(self._testtmp, True) | ||
|
r21497 | shutil.rmtree(self._threadtmp, True) | ||
|
r21454 | |||
|
r21455 | if (self._ret != 0 or self._out != self._refout) and not self._skipped \ | ||
|
r21510 | and not self._debug and self._out: | ||
|
r21507 | f = open(self.errpath, 'wb') | ||
|
r21455 | for line in self._out: | ||
f.write(line) | ||||
f.close() | ||||
|
r21452 | vlog("# Ret was:", self._ret) | ||
|
r21454 | def _run(self, replacements, env): | ||
|
r21339 | # This should be implemented in child classes to run tests. | ||
|
r21490 | raise SkipTest('unknown test type') | ||
|
r21296 | |||
|
r21520 | def abort(self): | ||
"""Terminate execution of this test.""" | ||||
self._aborted = True | ||||
|
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 = [ | ||
|
r21514 | (r':%s\b' % self._startport, ':$HGPORT'), | ||
(r':%s\b' % (self._startport + 1), ':$HGPORT1'), | ||||
(r':%s\b' % (self._startport + 2), ':$HGPORT2'), | ||||
|
r21298 | ] | ||
if os.name == 'nt': | ||||
r.append( | ||||
(''.join(c.isalpha() and '[%s%s]' % (c.lower(), c.upper()) or | ||||
c in '/\\' and r'[/\\]' or c.isdigit() and c or '\\' + c | ||||
|
r21454 | for c in self._testtmp), '$TESTTMP')) | ||
|
r21298 | else: | ||
|
r21454 | r.append((re.escape(self._testtmp), '$TESTTMP')) | ||
|
r21298 | |||
|
r21514 | return r | ||
|
r21298 | |||
|
r21514 | def _getenv(self): | ||
|
r21536 | """Obtain environment variables to use during test execution.""" | ||
|
r21299 | env = os.environ.copy() | ||
|
r21454 | env['TESTTMP'] = self._testtmp | ||
env['HOME'] = self._testtmp | ||||
|
r21514 | env["HGPORT"] = str(self._startport) | ||
env["HGPORT1"] = str(self._startport + 1) | ||||
env["HGPORT2"] = str(self._startport + 2) | ||||
|
r21310 | env["HGRCPATH"] = os.path.join(self._threadtmp, '.hgrc') | ||
env["DAEMON_PIDS"] = os.path.join(self._threadtmp, 'daemon.pids') | ||||
|
r21299 | env["HGEDITOR"] = sys.executable + ' -c "import sys; sys.exit(0)"' | ||
env["HGMERGE"] = "internal:merge" | ||||
env["HGUSER"] = "test" | ||||
env["HGENCODING"] = "ascii" | ||||
env["HGENCODINGMODE"] = "strict" | ||||
# Reset some environment variables to well-known values so that | ||||
# the tests produce repeatable output. | ||||
env['LANG'] = env['LC_ALL'] = env['LANGUAGE'] = 'C' | ||||
env['TZ'] = 'GMT' | ||||
env["EMAIL"] = "Foo Bar <foo.bar@example.com>" | ||||
env['COLUMNS'] = '80' | ||||
env['TERM'] = 'xterm' | ||||
for k in ('HG HGPROF CDPATH GREP_OPTIONS http_proxy no_proxy ' + | ||||
'NO_PROXY').split(): | ||||
if k in env: | ||||
del env[k] | ||||
# unset env related to hooks | ||||
for k in env.keys(): | ||||
if k.startswith('HG_'): | ||||
del env[k] | ||||
return env | ||||
|
r21382 | def _createhgrc(self, path): | ||
|
r21536 | """Create an hgrc file for this test.""" | ||
|
r21916 | hgrc = open(path, 'wb') | ||
|
r21382 | hgrc.write('[ui]\n') | ||
hgrc.write('slash = True\n') | ||||
hgrc.write('interactive = False\n') | ||||
|
r21918 | hgrc.write('mergemarkers = detailed\n') | ||
|
r23053 | hgrc.write('promptecho = True\n') | ||
|
r21382 | hgrc.write('[defaults]\n') | ||
hgrc.write('backout = -d "0 0"\n') | ||||
hgrc.write('commit = -d "0 0"\n') | ||||
hgrc.write('shelve = --date "0 0"\n') | ||||
hgrc.write('tag = -d "0 0"\n') | ||||
|
r21515 | for opt in self._extraconfigopts: | ||
section, key = opt.split('.', 1) | ||||
assert '=' in key, ('extra config opt %s must ' | ||||
'have an = for assignment' % opt) | ||||
hgrc.write('[%s]\n%s\n' % (section, key)) | ||||
|
r21382 | hgrc.close() | ||
|
r21523 | def fail(self, msg): | ||
|
r21522 | # unittest differentiates between errored and failed. | ||
# Failed is denoted by AssertionError (by default at least). | ||||
raise AssertionError(msg) | ||||
|
r21323 | |||
|
r21296 | class PythonTest(Test): | ||
"""A Python-based test.""" | ||||
|
r21501 | |||
@property | ||||
|
r21521 | def refpath(self): | ||
|
r21501 | return os.path.join(self._testdir, '%s.out' % self.name) | ||
|
r21454 | def _run(self, replacements, env): | ||
|
r21516 | py3kswitch = self._py3kwarnings and ' -3' or '' | ||
|
r21507 | cmd = '%s%s "%s"' % (PYTHON, py3kswitch, self.path) | ||
|
r21311 | vlog("# Running", cmd) | ||
if os.name == 'nt': | ||||
replacements.append((r'\r\n', '\n')) | ||||
|
r21520 | result = run(cmd, self._testtmp, replacements, env, | ||
|
r21513 | debug=self._debug, timeout=self._timeout) | ||
|
r21520 | if self._aborted: | ||
raise KeyboardInterrupt() | ||||
return result | ||||
|
r21311 | |||
|
r21296 | class TTest(Test): | ||
"""A "t test" is a test backed by a .t file.""" | ||||
|
r21381 | SKIPPED_PREFIX = 'skipped: ' | ||
FAILED_PREFIX = 'hghave check failed: ' | ||||
|
r21384 | NEEDESCAPE = re.compile(r'[\x00-\x08\x0b-\x1f\x7f-\xff]').search | ||
ESCAPESUB = re.compile(r'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub | ||||
|
r21539 | ESCAPEMAP = dict((chr(i), r'\x%02x' % i) for i in range(256)) | ||
ESCAPEMAP.update({'\\': '\\\\', '\r': r'\r'}) | ||||
|
r21381 | |||
|
r21501 | @property | ||
|
r21521 | def refpath(self): | ||
|
r21501 | return os.path.join(self._testdir, self.name) | ||
|
r21454 | def _run(self, replacements, env): | ||
|
r21916 | f = open(self.path, 'rb') | ||
|
r21313 | lines = f.readlines() | ||
f.close() | ||||
|
r21454 | salt, script, after, expected = self._parsetest(lines) | ||
|
r21313 | |||
# Write out the generated script. | ||||
|
r21454 | fname = '%s.sh' % self._testtmp | ||
|
r21916 | f = open(fname, 'wb') | ||
|
r21313 | for l in script: | ||
f.write(l) | ||||
f.close() | ||||
|
r21517 | cmd = '%s "%s"' % (self._shell, fname) | ||
|
r21313 | vlog("# Running", cmd) | ||
|
r21499 | exitcode, output = run(cmd, self._testtmp, replacements, env, | ||
|
r21520 | debug=self._debug, timeout=self._timeout) | ||
if self._aborted: | ||||
raise KeyboardInterrupt() | ||||
|
r21313 | # Do not merge output if skipped. Return hghave message instead. | ||
# Similarly, with --debug, output is None. | ||||
|
r21380 | if exitcode == self.SKIPPED_STATUS or output is None: | ||
|
r21313 | return exitcode, output | ||
|
r21314 | return self._processoutput(exitcode, output, salt, after, expected) | ||
|
r21296 | |||
|
r21454 | def _hghave(self, reqs): | ||
|
r21312 | # TODO do something smarter when all other uses of hghave are gone. | ||
|
r21341 | tdir = self._testdir.replace('\\', '/') | ||
|
r21312 | proc = Popen4('%s -c "%s/hghave %s"' % | ||
|
r21517 | (self._shell, tdir, ' '.join(reqs)), | ||
|
r21454 | self._testtmp, 0) | ||
|
r21312 | stdout, stderr = proc.communicate() | ||
ret = proc.wait() | ||||
if wifexited(ret): | ||||
ret = os.WEXITSTATUS(ret) | ||||
if ret == 2: | ||||
print stdout | ||||
sys.exit(1) | ||||
return ret == 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. | ||||
salt = "SALT" + str(time.time()) | ||||
def addsalt(line, inpython): | ||||
if inpython: | ||||
script.append('%s %d 0\n' % (salt, line)) | ||||
else: | ||||
script.append('echo %s %s $?\n' % (salt, line)) | ||||
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: | ||
|
r21312 | script.append('set -x\n') | ||
if os.getenv('MSYSTEM'): | ||||
script.append('alias pwd="pwd -W"\n') | ||||
for n, l in enumerate(lines): | ||||
if not l.endswith('\n'): | ||||
l += '\n' | ||||
|
r22045 | if l.startswith('#require'): | ||
lsplit = l.split() | ||||
if len(lsplit) < 2 or lsplit[0] != '#require': | ||||
after.setdefault(pos, []).append(' !!! invalid #require\n') | ||||
if not self._hghave(lsplit[1:]): | ||||
script = ["exit 80\n"] | ||||
break | ||||
after.setdefault(pos, []).append(l) | ||||
elif l.startswith('#if'): | ||||
|
r21312 | lsplit = l.split() | ||
if len(lsplit) < 2 or lsplit[0] != '#if': | ||||
after.setdefault(pos, []).append(' !!! invalid #if\n') | ||||
if skipping is not None: | ||||
after.setdefault(pos, []).append(' !!! nested #if\n') | ||||
|
r21454 | skipping = not self._hghave(lsplit[1:]) | ||
|
r21312 | after.setdefault(pos, []).append(l) | ||
elif l.startswith('#else'): | ||||
if skipping is None: | ||||
after.setdefault(pos, []).append(' !!! missing #if\n') | ||||
skipping = not skipping | ||||
after.setdefault(pos, []).append(l) | ||||
elif l.startswith('#endif'): | ||||
if skipping is None: | ||||
after.setdefault(pos, []).append(' !!! missing #if\n') | ||||
skipping = None | ||||
after.setdefault(pos, []).append(l) | ||||
elif skipping: | ||||
after.setdefault(pos, []).append(l) | ||||
elif l.startswith(' >>> '): # python inlines | ||||
after.setdefault(pos, []).append(l) | ||||
prepos = pos | ||||
pos = n | ||||
if not inpython: | ||||
# We've just entered a Python block. Add the header. | ||||
inpython = True | ||||
addsalt(prepos, False) # Make sure we report the exit code. | ||||
script.append('%s -m heredoctest <<EOF\n' % PYTHON) | ||||
addsalt(n, True) | ||||
script.append(l[2:]) | ||||
elif l.startswith(' ... '): # python inlines | ||||
after.setdefault(prepos, []).append(l) | ||||
script.append(l[2:]) | ||||
elif l.startswith(' $ '): # commands | ||||
if inpython: | ||||
script.append('EOF\n') | ||||
inpython = False | ||||
after.setdefault(pos, []).append(l) | ||||
prepos = pos | ||||
pos = n | ||||
addsalt(n, False) | ||||
cmd = l[4:].split() | ||||
if len(cmd) == 2 and cmd[0] == 'cd': | ||||
l = ' $ cd %s || exit 1\n' % cmd[1] | ||||
script.append(l[4:]) | ||||
elif l.startswith(' > '): # continuations | ||||
after.setdefault(prepos, []).append(l) | ||||
script.append(l[4:]) | ||||
elif l.startswith(' '): # results | ||||
# Queue up a list of expected results. | ||||
expected.setdefault(pos, []).append(l[2:]) | ||||
else: | ||||
if inpython: | ||||
script.append('EOF\n') | ||||
inpython = False | ||||
# Non-command/result. Queue up for merged output. | ||||
after.setdefault(pos, []).append(l) | ||||
if inpython: | ||||
script.append('EOF\n') | ||||
if skipping is not None: | ||||
after.setdefault(pos, []).append(' !!! missing #endif\n') | ||||
addsalt(n + 1, False) | ||||
return salt, script, after, expected | ||||
|
r21314 | def _processoutput(self, exitcode, output, salt, after, expected): | ||
# Merge the script output back into a unified test. | ||||
warnonly = 1 # 1: not yet; 2: yes; 3: for sure not | ||||
if exitcode != 0: | ||||
warnonly = 3 | ||||
pos = -1 | ||||
postout = [] | ||||
for l in output: | ||||
lout, lcmd = l, None | ||||
if salt in l: | ||||
lout, lcmd = l.split(salt, 1) | ||||
if lout: | ||||
if not lout.endswith('\n'): | ||||
lout += ' (no-eol)\n' | ||||
# Find the expected output at the current position. | ||||
el = None | ||||
if expected.get(pos, None): | ||||
el = expected[pos].pop(0) | ||||
|
r21315 | r = TTest.linematch(el, lout) | ||
|
r21314 | if isinstance(r, str): | ||
if r == '+glob': | ||||
lout = el[:-1] + ' (glob)\n' | ||||
r = '' # Warn only this line. | ||||
elif r == '-glob': | ||||
lout = ''.join(el.rsplit(' (glob)', 1)) | ||||
r = '' # Warn only this line. | ||||
else: | ||||
log('\ninfo, unknown linematch result: %r\n' % r) | ||||
r = False | ||||
if r: | ||||
postout.append(' ' + el) | ||||
else: | ||||
|
r21384 | if self.NEEDESCAPE(lout): | ||
|
r21538 | lout = TTest._stringescape('%s (esc)\n' % | ||
lout.rstrip('\n')) | ||||
|
r21314 | postout.append(' ' + lout) # Let diff deal with it. | ||
if r != '': # If line failed. | ||||
warnonly = 3 # for sure not | ||||
elif warnonly == 1: # Is "not yet" and line is warn only. | ||||
warnonly = 2 # Yes do warn. | ||||
if lcmd: | ||||
# Add on last return code. | ||||
ret = int(lcmd.split()[1]) | ||||
if ret != 0: | ||||
postout.append(' [%s]\n' % ret) | ||||
if pos in after: | ||||
# Merge in non-active test bits. | ||||
postout += after.pop(pos) | ||||
pos = int(lcmd.split()[0]) | ||||
if pos in after: | ||||
postout += after.pop(pos) | ||||
if warnonly == 2: | ||||
exitcode = False # Set exitcode to warned. | ||||
return exitcode, postout | ||||
|
r21312 | |||
|
r21315 | @staticmethod | ||
|
r21316 | def rematch(el, l): | ||
try: | ||||
# use \Z to ensure that the regex matches to the end of the string | ||||
if os.name == 'nt': | ||||
return re.match(el + r'\r?\n\Z', l) | ||||
return re.match(el + r'\n\Z', l) | ||||
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. | ||||
if el + '\n' == l: | ||||
if os.altsep: | ||||
# matching on "/" is not needed for this line | ||||
return '-glob' | ||||
return True | ||||
i, n = 0, len(el) | ||||
res = '' | ||||
while i < n: | ||||
c = el[i] | ||||
i += 1 | ||||
if c == '\\' and el[i] in '*?\\/': | ||||
res += el[i - 1:i + 1] | ||||
i += 1 | ||||
elif c == '*': | ||||
res += '.*' | ||||
elif c == '?': | ||||
res += '.' | ||||
elif c == '/' and os.altsep: | ||||
res += '[/\\\\]' | ||||
else: | ||||
res += re.escape(c) | ||||
return TTest.rematch(res, l) | ||||
@staticmethod | ||||
|
r21315 | def linematch(el, l): | ||
if el == l: # perfect match (fast) | ||||
return True | ||||
if el: | ||||
if el.endswith(" (esc)\n"): | ||||
el = el[:-7].decode('string-escape') + '\n' | ||||
if el == l or os.name == 'nt' and el[:-1] + '\r\n' == l: | ||||
return True | ||||
if el.endswith(" (re)\n"): | ||||
|
r21316 | return TTest.rematch(el[:-6], l) | ||
|
r21315 | if el.endswith(" (glob)\n"): | ||
|
r21317 | return TTest.globmatch(el[:-8], l) | ||
|
r21315 | if os.altsep and l.replace('\\', '/') == el: | ||
return '+glob' | ||||
return False | ||||
|
r21379 | @staticmethod | ||
def parsehghaveoutput(lines): | ||||
'''Parse hghave log lines. | ||||
Return tuple of lists (missing, failed): | ||||
* the missing/unknown features | ||||
* the features for which existence check failed''' | ||||
missing = [] | ||||
failed = [] | ||||
for line in lines: | ||||
|
r21381 | if line.startswith(TTest.SKIPPED_PREFIX): | ||
|
r21379 | line = line.splitlines()[0] | ||
|
r21381 | missing.append(line[len(TTest.SKIPPED_PREFIX):]) | ||
elif line.startswith(TTest.FAILED_PREFIX): | ||||
|
r21379 | line = line.splitlines()[0] | ||
|
r21381 | failed.append(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) | ||||
|
r13348 | wifexited = getattr(os, "WIFEXITED", lambda x: False) | ||
|
r21520 | def run(cmd, wd, replacements, env, debug=False, timeout=None): | ||
|
r2110 | """Run command in a sub-process, capturing the output (stdout and stderr). | ||
|
r9707 | Return a tuple (exitcode, output). output is None in debug mode.""" | ||
|
r21499 | if debug: | ||
|
r19262 | proc = subprocess.Popen(cmd, shell=True, cwd=wd, env=env) | ||
|
r9707 | ret = proc.wait() | ||
return (ret, None) | ||||
|
r21499 | proc = Popen4(cmd, wd, timeout, env) | ||
|
r14338 | def cleanup(): | ||
|
r14821 | terminate(proc) | ||
|
r14338 | ret = proc.wait() | ||
if ret == 0: | ||||
ret = signal.SIGTERM << 8 | ||||
|
r19263 | killdaemons(env['DAEMON_PIDS']) | ||
|
r14338 | return ret | ||
output = '' | ||||
proc.tochild.close() | ||||
|
r10336 | |||
|
r14338 | try: | ||
output = proc.fromchild.read() | ||||
except KeyboardInterrupt: | ||||
vlog('# Handling keyboard interrupt') | ||||
cleanup() | ||||
raise | ||||
|
r10336 | |||
|
r19413 | ret = proc.wait() | ||
|
r14338 | if wifexited(ret): | ||
ret = os.WEXITSTATUS(ret) | ||||
|
r14001 | |||
|
r14338 | if proc.timeout: | ||
ret = 'timeout' | ||||
|
r14001 | |||
|
r14338 | if ret: | ||
|
r19263 | killdaemons(env['DAEMON_PIDS']) | ||
|
r14001 | |||
|
r12639 | for s, r in replacements: | ||
|
r12895 | output = re.sub(s, r, output) | ||
|
r17742 | return ret, output.splitlines(True) | ||
|
r2110 | |||
|
r22104 | iolock = threading.RLock() | ||
|
r14000 | |||
|
r21442 | class SkipTest(Exception): | ||
"""Raised to indicate that a test is to be skipped.""" | ||||
|
r21443 | class IgnoreTest(Exception): | ||
"""Raised to indicate that a test is to be ignored.""" | ||||
|
r21444 | class WarnTest(Exception): | ||
"""Raised to indicate that a test warned.""" | ||||
|
r21429 | class TestResult(unittest._TextTestResult): | ||
"""Holds results when executing via unittest.""" | ||||
# Don't worry too much about accessing the non-public _TextTestResult. | ||||
# It is relatively common in Python testing tools. | ||||
|
r21460 | def __init__(self, options, *args, **kwargs): | ||
|
r21429 | super(TestResult, self).__init__(*args, **kwargs) | ||
|
r21460 | self._options = options | ||
|
r21430 | # unittest.TestResult didn't have skipped until 2.7. We need to | ||
# polyfill it. | ||||
self.skipped = [] | ||||
|
r21431 | # We have a custom "ignored" result that isn't present in any Python | ||
# unittest implementation. It is very similar to skipped. It may make | ||||
# sense to map it into skip some day. | ||||
self.ignored = [] | ||||
|
r21433 | # We have a custom "warned" result that isn't present in any Python | ||
# unittest implementation. It is very similar to failed. It may make | ||||
# sense to map it into fail some day. | ||||
self.warned = [] | ||||
|
r21495 | self.times = [] | ||
self._started = {} | ||||
|
r21977 | self._stopped = {} | ||
|
r22044 | # Data stored for the benefit of generating xunit reports. | ||
self.successes = [] | ||||
self.faildata = {} | ||||
|
r21495 | |||
|
r21462 | def addFailure(self, test, reason): | ||
self.failures.append((test, reason)) | ||||
|
r21460 | |||
if self._options.first: | ||||
self.stop() | ||||
|
r21735 | else: | ||
|
r21993 | iolock.acquire() | ||
|
r21735 | if not self._options.nodiff: | ||
self.stream.write('\nERROR: %s output changed\n' % test) | ||||
|
r21754 | |||
|
r21736 | self.stream.write('!') | ||
|
r22146 | self.stream.flush() | ||
|
r21993 | iolock.release() | ||
|
r21460 | |||
|
r22044 | def addSuccess(self, test): | ||
|
r22104 | iolock.acquire() | ||
|
r22044 | super(TestResult, self).addSuccess(test) | ||
|
r22104 | iolock.release() | ||
|
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)) | ||||
|
r22104 | iolock.acquire() | ||
|
r21430 | if self.showAll: | ||
self.stream.writeln('skipped %s' % reason) | ||||
else: | ||||
self.stream.write('s') | ||||
self.stream.flush() | ||||
|
r22104 | iolock.release() | ||
|
r21430 | |||
|
r21431 | def addIgnore(self, test, reason): | ||
self.ignored.append((test, reason)) | ||||
|
r22104 | iolock.acquire() | ||
|
r21431 | if self.showAll: | ||
self.stream.writeln('ignored %s' % reason) | ||||
else: | ||||
|
r22107 | if reason != 'not retesting' and reason != "doesn't match keyword": | ||
|
r21739 | self.stream.write('i') | ||
|
r21997 | else: | ||
self.testsRun += 1 | ||||
|
r21431 | self.stream.flush() | ||
|
r22104 | iolock.release() | ||
|
r21431 | |||
|
r21433 | def addWarn(self, test, reason): | ||
self.warned.append((test, reason)) | ||||
|
r21460 | if self._options.first: | ||
self.stop() | ||||
|
r22104 | iolock.acquire() | ||
|
r21433 | if self.showAll: | ||
self.stream.writeln('warned %s' % reason) | ||||
else: | ||||
self.stream.write('~') | ||||
self.stream.flush() | ||||
|
r22104 | iolock.release() | ||
|
r21433 | |||
|
r21523 | def addOutputMismatch(self, test, ret, got, expected): | ||
|
r21521 | """Record a mismatch in test output for a particular test.""" | ||
|
r22838 | if self.shouldStop: | ||
# don't print, some other test case already failed and | ||||
# printed, we're just stale and probably failed due to our | ||||
# temp dir getting cleaned up. | ||||
return | ||||
|
r21521 | |||
|
r21763 | accepted = False | ||
|
r22044 | failed = False | ||
lines = [] | ||||
|
r21763 | |||
iolock.acquire() | ||||
|
r21521 | if self._options.nodiff: | ||
|
r21763 | pass | ||
elif self._options.view: | ||||
|
r21919 | os.system("%s %s %s" % | ||
(self._options.view, test.refpath, test.errpath)) | ||||
|
r21521 | else: | ||
|
r22839 | servefail, lines = getdiff(expected, got, | ||
test.refpath, test.errpath) | ||||
if servefail: | ||||
self.addFailure( | ||||
test, | ||||
'server failed to start (HGPORT=%s)' % test._startport) | ||||
|
r21521 | else: | ||
self.stream.write('\n') | ||||
for line in lines: | ||||
self.stream.write(line) | ||||
self.stream.flush() | ||||
|
r22361 | # handle interactive prompt without releasing iolock | ||
if self._options.interactive: | ||||
self.stream.write('Accept this change? [n] ') | ||||
answer = sys.stdin.readline().strip() | ||||
if answer.lower() in ('y', 'yes'): | ||||
if test.name.endswith('.t'): | ||||
rename(test.errpath, test.path) | ||||
else: | ||||
rename(test.errpath, '%s.out' % test.path) | ||||
accepted = True | ||||
if not accepted and not failed: | ||||
self.faildata[test.name] = ''.join(lines) | ||||
|
r21763 | iolock.release() | ||
return accepted | ||||
|
r21523 | |||
|
r21495 | def startTest(self, test): | ||
super(TestResult, self).startTest(test) | ||||
|
r21977 | # os.times module computes the user time and system time spent by | ||
# child's processes along with real elapsed time taken by a process. | ||||
# This module has one limitation. It can only work for Linux user | ||||
# and not for Windows. | ||||
self._started[test.name] = os.times() | ||||
|
r21495 | |||
def stopTest(self, test, interrupted=False): | ||||
super(TestResult, self).stopTest(test) | ||||
|
r21977 | self._stopped[test.name] = os.times() | ||
starttime = self._started[test.name] | ||||
endtime = self._stopped[test.name] | ||||
self.times.append((test.name, endtime[2] - starttime[2], | ||||
endtime[3] - starttime[3], endtime[4] - starttime[4])) | ||||
|
r21495 | del self._started[test.name] | ||
|
r21977 | del self._stopped[test.name] | ||
|
r21495 | |||
if interrupted: | ||||
|
r22104 | iolock.acquire() | ||
|
r21495 | self.stream.writeln('INTERRUPTED: %s (after %d seconds)' % ( | ||
|
r21977 | test.name, self.times[-1][3])) | ||
|
r22104 | iolock.release() | ||
|
r21495 | |||
|
r21439 | class TestSuite(unittest.TestSuite): | ||
|
r23139 | """Custom unittest TestSuite that knows how to execute Mercurial tests.""" | ||
|
r21528 | |||
|
r21533 | def __init__(self, testdir, jobs=1, whitelist=None, blacklist=None, | ||
|
r21532 | retest=False, keywords=None, loop=False, | ||
|
r21529 | *args, **kwargs): | ||
|
r21528 | """Create a new instance that can run tests with a configuration. | ||
|
r21439 | |||
|
r21533 | testdir specifies the directory where tests are executed from. This | ||
is typically the ``tests`` directory from Mercurial's source | ||||
repository. | ||||
|
r21528 | jobs specifies the number of jobs to run concurrently. Each test | ||
executes on its own thread. Tests actually spawn new processes, so | ||||
state mutation should not be an issue. | ||||
|
r21529 | |||
whitelist and blacklist denote tests that have been whitelisted and | ||||
blacklisted, respectively. These arguments don't belong in TestSuite. | ||||
Instead, whitelist and blacklist should be handled by the thing that | ||||
populates the TestSuite with tests. They are present to preserve | ||||
backwards compatible behavior which reports skipped tests as part | ||||
of the results. | ||||
|
r21530 | |||
retest denotes whether to retest failed tests. This arguably belongs | ||||
outside of TestSuite. | ||||
|
r21531 | |||
keywords denotes key words that will be used to filter which tests | ||||
to execute. This arguably belongs outside of TestSuite. | ||||
|
r21532 | |||
loop denotes whether to loop over tests forever. | ||||
|
r21528 | """ | ||
|
r21439 | super(TestSuite, self).__init__(*args, **kwargs) | ||
|
r21528 | self._jobs = jobs | ||
|
r21529 | self._whitelist = whitelist | ||
self._blacklist = blacklist | ||||
|
r21530 | self._retest = retest | ||
|
r21531 | self._keywords = keywords | ||
|
r21532 | self._loop = loop | ||
|
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 = [] | ||||
for test in self._tests: | ||||
if not os.path.exists(test.path): | ||||
result.addSkip(test, "Doesn't exist") | ||||
continue | ||||
|
r21529 | if not (self._whitelist and test.name in self._whitelist): | ||
if self._blacklist and test.name in self._blacklist: | ||||
|
r21507 | result.addSkip(test, 'blacklisted') | ||
continue | ||||
|
r21530 | if self._retest and not os.path.exists(test.errpath): | ||
|
r21507 | result.addIgnore(test, 'not retesting') | ||
continue | ||||
|
r21531 | if self._keywords: | ||
|
r21916 | f = open(test.path, 'rb') | ||
|
r21507 | t = f.read().lower() + test.name.lower() | ||
f.close() | ||||
ignored = False | ||||
|
r21531 | for k in self._keywords.lower().split(): | ||
|
r21507 | if k not in t: | ||
result.addIgnore(test, "doesn't match keyword") | ||||
ignored = True | ||||
break | ||||
if ignored: | ||||
continue | ||||
tests.append(test) | ||||
|
r21496 | |||
|
r21520 | runtests = list(tests) | ||
|
r21496 | done = queue.Queue() | ||
running = 0 | ||||
def job(test, result): | ||||
try: | ||||
test(result) | ||||
done.put(None) | ||||
except KeyboardInterrupt: | ||||
pass | ||||
except: # re-raises | ||||
done.put(('!', test, 'run-test raised an error, see traceback')) | ||||
raise | ||||
try: | ||||
while tests or running: | ||||
|
r21528 | if not done.empty() or running == self._jobs or not tests: | ||
|
r21496 | try: | ||
done.get(True, 1) | ||||
if result and result.shouldStop: | ||||
break | ||||
except queue.Empty: | ||||
continue | ||||
running -= 1 | ||||
|
r21528 | if tests and not running == self._jobs: | ||
|
r21496 | test = tests.pop(0) | ||
|
r21532 | if self._loop: | ||
|
r21496 | tests.append(test) | ||
t = threading.Thread(target=job, name=test.name, | ||||
args=(test, result)) | ||||
t.start() | ||||
running += 1 | ||||
except KeyboardInterrupt: | ||||
|
r21520 | for test in runtests: | ||
test.abort() | ||||
|
r21439 | |||
return result | ||||
|
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 | ||||
def run(self, test): | ||||
|
r21460 | result = TestResult(self._runner.options, self.stream, | ||
self.descriptions, self.verbosity) | ||||
|
r21459 | |||
test(result) | ||||
failed = len(result.failures) | ||||
warned = len(result.warned) | ||||
skipped = len(result.skipped) | ||||
ignored = len(result.ignored) | ||||
|
r22104 | iolock.acquire() | ||
|
r21459 | self.stream.writeln('') | ||
if not self._runner.options.noskips: | ||||
for test, msg in result.skipped: | ||||
self.stream.writeln('Skipped %s: %s' % (test.name, msg)) | ||||
for test, msg in result.warned: | ||||
self.stream.writeln('Warned %s: %s' % (test.name, msg)) | ||||
for test, msg in result.failures: | ||||
self.stream.writeln('Failed %s: %s' % (test.name, msg)) | ||||
for test, msg in result.errors: | ||||
self.stream.writeln('Errored %s: %s' % (test.name, msg)) | ||||
|
r22044 | if self._runner.options.xunit: | ||
xuf = open(self._runner.options.xunit, 'wb') | ||||
try: | ||||
timesd = dict( | ||||
(test, real) for test, cuser, csys, real in result.times) | ||||
doc = minidom.Document() | ||||
s = doc.createElement('testsuite') | ||||
s.setAttribute('name', 'run-tests') | ||||
s.setAttribute('tests', str(result.testsRun)) | ||||
s.setAttribute('errors', "0") # TODO | ||||
s.setAttribute('failures', str(failed)) | ||||
s.setAttribute('skipped', str(skipped + ignored)) | ||||
doc.appendChild(s) | ||||
for tc in result.successes: | ||||
t = doc.createElement('testcase') | ||||
t.setAttribute('name', tc.name) | ||||
t.setAttribute('time', '%.3f' % timesd[tc.name]) | ||||
s.appendChild(t) | ||||
for tc, err in sorted(result.faildata.iteritems()): | ||||
t = doc.createElement('testcase') | ||||
t.setAttribute('name', tc) | ||||
t.setAttribute('time', '%.3f' % timesd[tc]) | ||||
cd = doc.createCDATASection(cdatasafe(err)) | ||||
t.appendChild(cd) | ||||
s.appendChild(t) | ||||
xuf.write(doc.toprettyxml(indent=' ', encoding='utf-8')) | ||||
finally: | ||||
xuf.close() | ||||
|
r22391 | if self._runner.options.json: | ||
if json is None: | ||||
raise ImportError("json module not installed") | ||||
jsonpath = os.path.join(self._runner._testdir, 'report.json') | ||||
fp = open(jsonpath, 'w') | ||||
try: | ||||
timesd = {} | ||||
for test, cuser, csys, real in result.times: | ||||
|
r22486 | timesd[test] = (real, cuser, csys) | ||
|
r22391 | |||
outcome = {} | ||||
for tc in result.successes: | ||||
testresult = {'result': 'success', | ||||
|
r22486 | 'time': ('%0.3f' % timesd[tc.name][0]), | ||
'cuser': ('%0.3f' % timesd[tc.name][1]), | ||||
'csys': ('%0.3f' % timesd[tc.name][2])} | ||||
|
r22391 | outcome[tc.name] = testresult | ||
for tc, err in sorted(result.faildata.iteritems()): | ||||
testresult = {'result': 'failure', | ||||
|
r22486 | 'time': ('%0.3f' % timesd[tc][0]), | ||
'cuser': ('%0.3f' % timesd[tc][1]), | ||||
'csys': ('%0.3f' % timesd[tc][2])} | ||||
|
r22391 | outcome[tc] = testresult | ||
for tc, reason in result.skipped: | ||||
testresult = {'result': 'skip', | ||||
|
r22486 | 'time': ('%0.3f' % timesd[tc.name][0]), | ||
'cuser': ('%0.3f' % timesd[tc.name][1]), | ||||
'csys': ('%0.3f' % timesd[tc.name][2])} | ||||
|
r22391 | outcome[tc.name] = testresult | ||
jsonout = json.dumps(outcome, sort_keys=True, indent=4) | ||||
fp.writelines(("testreport =", jsonout)) | ||||
finally: | ||||
fp.close() | ||||
|
r21459 | self._runner._checkhglib('Tested') | ||
self.stream.writeln('# Ran %d tests, %d skipped, %d warned, %d failed.' | ||||
|
r21997 | % (result.testsRun, | ||
|
r21459 | skipped + ignored, warned, failed)) | ||
if failed: | ||||
self.stream.writeln('python hash seed: %s' % | ||||
os.environ['PYTHONHASHSEED']) | ||||
if self._runner.options.time: | ||||
|
r21495 | self.printtimes(result.times) | ||
|
r21494 | |||
|
r22104 | iolock.release() | ||
|
r21613 | return result | ||
|
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])) | ||
cols = '%7.3f %7.3f %7.3f %s' | ||||
self.stream.writeln('%-7s %-7s %-7s %s' % ('cuser', 'csys', 'real', | ||||
'Test')) | ||||
for test, cuser, csys, real in times: | ||||
self.stream.writeln(cols % (cuser, csys, real, test)) | ||||
|
r21429 | |||
|
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 = [ | ||
os.path.basename(sys.executable), | ||||
'diff', | ||||
'grep', | ||||
'unzip', | ||||
'gunzip', | ||||
'bunzip2', | ||||
'sed', | ||||
] | ||||
|
r21536 | # Maps file extensions to test class. | ||
|
r21357 | TESTTYPES = [ | ||
|
r21501 | ('.py', PythonTest), | ||
('.t', TTest), | ||||
|
r21357 | ] | ||
|
r21341 | def __init__(self): | ||
|
r21348 | self.options = None | ||
|
r21534 | self._testdir = None | ||
self._hgtmp = None | ||||
self._installdir = None | ||||
self._bindir = None | ||||
self._tmpbinddir = None | ||||
self._pythondir = None | ||||
self._coveragefile = None | ||||
|
r21352 | self._createdfiles = [] | ||
|
r21385 | self._hgpath = None | ||
|
r21340 | |||
|
r21376 | def run(self, args, parser=None): | ||
|
r21366 | """Run the test suite.""" | ||
|
r21375 | oldmask = os.umask(022) | ||
try: | ||||
|
r21376 | parser = parser or getparser() | ||
options, args = parseargs(args, parser) | ||||
self.options = options | ||||
|
r21375 | self._checktools() | ||
tests = self.findtests(args) | ||||
return self._run(tests) | ||||
finally: | ||||
os.umask(oldmask) | ||||
|
r21366 | |||
def _run(self, tests): | ||||
|
r21372 | if self.options.random: | ||
random.shuffle(tests) | ||||
else: | ||||
# keywords for slow tests | ||||
slow = 'svn gendoc check-code-hg'.split() | ||||
def sortkey(f): | ||||
# run largest tests first, as they tend to take the longest | ||||
try: | ||||
val = -os.stat(f).st_size | ||||
except OSError, e: | ||||
if e.errno != errno.ENOENT: | ||||
raise | ||||
return -1e9 # file does not exist, tell early | ||||
for kw in slow: | ||||
if kw in f: | ||||
val *= 10 | ||||
return val | ||||
tests.sort(key=sortkey) | ||||
|
r21534 | self._testdir = os.environ['TESTDIR'] = os.getcwd() | ||
|
r21371 | |||
|
r21370 | if 'PYTHONHASHSEED' not in os.environ: | ||
# use a random python hash seed all the time | ||||
# we do the randomness ourself to know what seed is used | ||||
os.environ['PYTHONHASHSEED'] = str(random.getrandbits(32)) | ||||
|
r21369 | if self.options.tmpdir: | ||
self.options.keep_tmpdir = True | ||||
tmpdir = self.options.tmpdir | ||||
if os.path.exists(tmpdir): | ||||
# Meaning of tmpdir has changed since 1.3: we used to create | ||||
# HGTMP inside tmpdir; now HGTMP is tmpdir. So fail if | ||||
# tmpdir already exists. | ||||
print "error: temp dir %r already exists" % tmpdir | ||||
return 1 | ||||
# Automatically removing tmpdir sounds convenient, but could | ||||
# really annoy anyone in the habit of using "--tmpdir=/tmp" | ||||
# or "--tmpdir=$HOME". | ||||
#vlog("# Removing temp dir", tmpdir) | ||||
#shutil.rmtree(tmpdir) | ||||
os.makedirs(tmpdir) | ||||
else: | ||||
d = None | ||||
if os.name == 'nt': | ||||
# without this, we get the default temp dir location, but | ||||
# in all lowercase, which causes troubles with paths (issue3490) | ||||
d = os.getenv('TMP') | ||||
tmpdir = tempfile.mkdtemp('', 'hgtests.', d) | ||||
|
r21534 | self._hgtmp = os.environ['HGTMP'] = os.path.realpath(tmpdir) | ||
|
r21369 | |||
|
r21368 | if self.options.with_hg: | ||
|
r21534 | self._installdir = None | ||
self._bindir = os.path.dirname(os.path.realpath( | ||||
self.options.with_hg)) | ||||
self._tmpbindir = os.path.join(self._hgtmp, 'install', 'bin') | ||||
os.makedirs(self._tmpbindir) | ||||
|
r21368 | |||
# This looks redundant with how Python initializes sys.path from | ||||
# the location of the script being executed. Needed because the | ||||
# "hg" specified by --with-hg is not the only Python script | ||||
# executed in the test suite that needs to import 'mercurial' | ||||
# ... which means it's not really redundant at all. | ||||
|
r21534 | self._pythondir = self._bindir | ||
|
r21368 | else: | ||
|
r21534 | self._installdir = os.path.join(self._hgtmp, "install") | ||
self._bindir = os.environ["BINDIR"] = \ | ||||
os.path.join(self._installdir, "bin") | ||||
self._tmpbindir = self._bindir | ||||
self._pythondir = os.path.join(self._installdir, "lib", "python") | ||||
|
r21368 | |||
|
r21534 | os.environ["BINDIR"] = self._bindir | ||
|
r21368 | os.environ["PYTHON"] = PYTHON | ||
|
r21534 | path = [self._bindir] + os.environ["PATH"].split(os.pathsep) | ||
if self._tmpbindir != self._bindir: | ||||
path = [self._tmpbindir] + path | ||||
|
r21368 | os.environ["PATH"] = os.pathsep.join(path) | ||
|
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. | ||||
|
r21534 | pypath = [self._pythondir, self._testdir, | ||
|
r21367 | os.path.abspath(os.path.dirname(__file__))] | ||
# We have to augment PYTHONPATH, rather than simply replacing | ||||
# it, in case external libraries are only available via current | ||||
# PYTHONPATH. (In particular, the Subversion bindings on OS X | ||||
# are in /opt/subversion.) | ||||
oldpypath = os.environ.get(IMPL_PATH) | ||||
if oldpypath: | ||||
pypath.append(oldpypath) | ||||
os.environ[IMPL_PATH] = os.pathsep.join(pypath) | ||||
|
r21534 | self._coveragefile = os.path.join(self._testdir, '.coverage') | ||
|
r21367 | |||
|
r21534 | vlog("# Using TESTDIR", self._testdir) | ||
vlog("# Using HGTMP", self._hgtmp) | ||||
|
r21366 | vlog("# Using PATH", os.environ["PATH"]) | ||
vlog("# Using", IMPL_PATH, os.environ[IMPL_PATH]) | ||||
try: | ||||
return self._runtests(tests) or 0 | ||||
finally: | ||||
time.sleep(.1) | ||||
self._cleanup() | ||||
|
r21363 | def findtests(self, args): | ||
"""Finds possible test files from arguments. | ||||
If you wish to inject custom tests into the test harness, this would | ||||
be a good function to monkeypatch or override in a derived class. | ||||
""" | ||||
if not args: | ||||
if self.options.changed: | ||||
proc = Popen4('hg st --rev "%s" -man0 .' % | ||||
self.options.changed, None, 0) | ||||
stdout, stderr = proc.communicate() | ||||
args = stdout.strip('\0').split('\0') | ||||
else: | ||||
args = os.listdir('.') | ||||
return [t for t in args | ||||
if os.path.basename(t).startswith('test-') | ||||
and (t.endswith('.py') or t.endswith('.t'))] | ||||
|
r21366 | def _runtests(self, tests): | ||
|
r21360 | try: | ||
|
r21534 | if self._installdir: | ||
|
r21378 | self._installhg() | ||
self._checkhglib("Testing") | ||||
|
r21360 | else: | ||
|
r21378 | self._usecorrectpython() | ||
|
r21360 | |||
if self.options.restart: | ||||
orig = list(tests) | ||||
while tests: | ||||
if os.path.exists(tests[0] + ".err"): | ||||
break | ||||
tests.pop(0) | ||||
if not tests: | ||||
print "running all tests" | ||||
tests = orig | ||||
|
r21464 | tests = [self._gettest(t, i) for i, t in enumerate(tests)] | ||
|
r21437 | |||
|
r21458 | failed = False | ||
warned = False | ||||
|
r21534 | suite = TestSuite(self._testdir, | ||
|
r21533 | jobs=self.options.jobs, | ||
|
r21529 | whitelist=self.options.whitelisted, | ||
blacklist=self.options.blacklist, | ||||
|
r21530 | retest=self.options.retest, | ||
|
r21531 | keywords=self.options.keywords, | ||
|
r21532 | loop=self.options.loop, | ||
|
r21529 | tests=tests) | ||
|
r21464 | verbosity = 1 | ||
if self.options.verbose: | ||||
verbosity = 2 | ||||
runner = TextTestRunner(self, verbosity=verbosity) | ||||
|
r21613 | result = runner.run(suite) | ||
if result.failures: | ||||
failed = True | ||||
if result.warned: | ||||
warned = True | ||||
|
r21360 | |||
if self.options.anycoverage: | ||||
|
r21378 | self._outputcoverage() | ||
|
r21360 | except KeyboardInterrupt: | ||
failed = True | ||||
print "\ninterrupted!" | ||||
if failed: | ||||
return 1 | ||||
if warned: | ||||
return 80 | ||||
|
r21464 | def _gettest(self, test, 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. | ||||
""" | ||||
lctest = test.lower() | ||||
testcls = Test | ||||
|
r21501 | for ext, cls in self.TESTTYPES: | ||
|
r21357 | if lctest.endswith(ext): | ||
testcls = cls | ||||
break | ||||
|
r21534 | refpath = os.path.join(self._testdir, test) | ||
tmpdir = os.path.join(self._hgtmp, 'child%d' % count) | ||||
|
r21504 | |||
|
r21520 | return testcls(refpath, tmpdir, | ||
|
r21510 | keeptmpdir=self.options.keep_tmpdir, | ||
|
r21511 | debug=self.options.debug, | ||
|
r21514 | timeout=self.options.timeout, | ||
|
r21515 | startport=self.options.port + count * 3, | ||
|
r21516 | extraconfigopts=self.options.extra_config_opt, | ||
|
r21517 | py3kwarnings=self.options.py3k_warnings, | ||
shell=self.options.shell) | ||||
|
r21357 | |||
|
r21366 | def _cleanup(self): | ||
|
r21350 | """Clean up state from this test invocation.""" | ||
if self.options.keep_tmpdir: | ||||
return | ||||
|
r21534 | vlog("# Cleaning up HGTMP", self._hgtmp) | ||
shutil.rmtree(self._hgtmp, True) | ||||
|
r21352 | for f in self._createdfiles: | ||
|
r21350 | try: | ||
os.remove(f) | ||||
except OSError: | ||||
pass | ||||
|
r21378 | def _usecorrectpython(self): | ||
|
r21536 | """Configure the environment to use the appropriate Python in tests.""" | ||
# Tests must use the same interpreter as us or bad things will happen. | ||||
|
r21351 | pyexename = sys.platform == 'win32' and 'python.exe' or 'python' | ||
if getattr(os, 'symlink', None): | ||||
vlog("# Making python executable in test path a symlink to '%s'" % | ||||
sys.executable) | ||||
|
r21534 | mypython = os.path.join(self._tmpbindir, pyexename) | ||
|
r21351 | try: | ||
if os.readlink(mypython) == sys.executable: | ||||
return | ||||
os.unlink(mypython) | ||||
except OSError, err: | ||||
if err.errno != errno.ENOENT: | ||||
raise | ||||
|
r21365 | if self._findprogram(pyexename) != sys.executable: | ||
|
r21351 | try: | ||
os.symlink(sys.executable, mypython) | ||||
|
r21352 | self._createdfiles.append(mypython) | ||
|
r21351 | except OSError, err: | ||
# child processes may race, which is harmless | ||||
if err.errno != errno.EEXIST: | ||||
raise | ||||
else: | ||||
exedir, exename = os.path.split(sys.executable) | ||||
vlog("# Modifying search path to find %s as %s in '%s'" % | ||||
(exename, pyexename, exedir)) | ||||
path = os.environ['PATH'].split(os.pathsep) | ||||
while exedir in path: | ||||
path.remove(exedir) | ||||
os.environ['PATH'] = os.pathsep.join([exedir] + path) | ||||
|
r21365 | if not self._findprogram(pyexename): | ||
|
r21351 | print "WARNING: Cannot find %s in search path" % pyexename | ||
|
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") | ||
installerrs = os.path.join("tests", "install.err") | ||||
compiler = '' | ||||
if self.options.compiler: | ||||
compiler = '--compiler ' + self.options.compiler | ||||
pure = self.options.pure and "--pure" or "" | ||||
py3 = '' | ||||
if sys.version_info[0] == 3: | ||||
py3 = '--c2to3' | ||||
# Run installer in hg root | ||||
script = os.path.realpath(sys.argv[0]) | ||||
hgroot = os.path.dirname(os.path.dirname(script)) | ||||
os.chdir(hgroot) | ||||
nohome = '--home=""' | ||||
if os.name == 'nt': | ||||
# The --home="" trick works only on OS where os.sep == '/' | ||||
# because of a distutils convert_path() fast-path. Avoid it at | ||||
# least on Windows for now, deal with .pydistutils.cfg bugs | ||||
# when they happen. | ||||
nohome = '' | ||||
cmd = ('%(exe)s setup.py %(py3)s %(pure)s clean --all' | ||||
' build %(compiler)s --build-base="%(base)s"' | ||||
' install --force --prefix="%(prefix)s"' | ||||
' --install-lib="%(libdir)s"' | ||||
' --install-scripts="%(bindir)s" %(nohome)s >%(logfile)s 2>&1' | ||||
% {'exe': sys.executable, 'py3': py3, 'pure': pure, | ||||
'compiler': compiler, | ||||
|
r21534 | 'base': os.path.join(self._hgtmp, "build"), | ||
'prefix': self._installdir, 'libdir': self._pythondir, | ||||
'bindir': self._bindir, | ||||
|
r21353 | 'nohome': nohome, 'logfile': installerrs}) | ||
vlog("# Running", cmd) | ||||
if os.system(cmd) == 0: | ||||
if not self.options.verbose: | ||||
os.remove(installerrs) | ||||
else: | ||||
|
r21916 | f = open(installerrs, 'rb') | ||
|
r21353 | for line in f: | ||
|
r22122 | print line | ||
|
r21353 | f.close() | ||
sys.exit(1) | ||||
|
r21534 | os.chdir(self._testdir) | ||
|
r21353 | |||
|
r21378 | self._usecorrectpython() | ||
|
r21353 | |||
if self.options.py3k_warnings and not self.options.anycoverage: | ||||
vlog("# Updating hg command to enable Py3k Warnings switch") | ||||
|
r21916 | f = open(os.path.join(self._bindir, 'hg'), 'rb') | ||
|
r21353 | lines = [line.rstrip() for line in f] | ||
lines[0] += ' -3' | ||||
f.close() | ||||
|
r21916 | f = open(os.path.join(self._bindir, 'hg'), 'wb') | ||
|
r21353 | for line in lines: | ||
f.write(line + '\n') | ||||
f.close() | ||||
|
r21534 | hgbat = os.path.join(self._bindir, 'hg.bat') | ||
|
r21353 | if os.path.isfile(hgbat): | ||
# hg.bat expects to be put in bin/scripts while run-tests.py | ||||
# installation layout put it in bin/ directly. Fix it | ||||
f = open(hgbat, 'rb') | ||||
data = f.read() | ||||
f.close() | ||||
if '"%~dp0..\python" "%~dp0hg" %*' in data: | ||||
data = data.replace('"%~dp0..\python" "%~dp0hg" %*', | ||||
'"%~dp0python" "%~dp0hg" %*') | ||||
f = open(hgbat, 'wb') | ||||
f.write(data) | ||||
f.close() | ||||
else: | ||||
print 'WARNING: cannot fix hg.bat reference to python.exe' | ||||
if self.options.anycoverage: | ||||
|
r21534 | custom = os.path.join(self._testdir, 'sitecustomize.py') | ||
target = os.path.join(self._pythondir, 'sitecustomize.py') | ||||
|
r21353 | vlog('# Installing coverage trigger to %s' % target) | ||
shutil.copyfile(custom, target) | ||||
|
r21534 | rc = os.path.join(self._testdir, '.coveragerc') | ||
|
r21353 | vlog('# Installing coverage rc to %s' % rc) | ||
os.environ['COVERAGE_PROCESS_START'] = rc | ||||
|
r21534 | fn = os.path.join(self._installdir, '..', '.coverage') | ||
|
r21353 | os.environ['COVERAGE_FILE'] = fn | ||
|
r21378 | def _checkhglib(self, verb): | ||
|
r21354 | """Ensure that the 'mercurial' package imported by python is | ||
the one we expect it to be. If not, print a warning to stderr.""" | ||||
|
r21733 | if ((self._bindir == self._pythondir) and | ||
(self._bindir != self._tmpbindir)): | ||||
|
r23139 | # The pythondir has been inferred from --with-hg flag. | ||
# We cannot expect anything sensible here. | ||||
|
r21733 | return | ||
|
r21534 | expecthg = os.path.join(self._pythondir, 'mercurial') | ||
|
r21385 | actualhg = self._gethgpath() | ||
|
r21354 | if os.path.abspath(actualhg) != os.path.abspath(expecthg): | ||
sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n' | ||||
' (expected %s)\n' | ||||
% (verb, actualhg, expecthg)) | ||||
|
r21385 | def _gethgpath(self): | ||
"""Return the path to the mercurial package that is actually found by | ||||
the current Python interpreter.""" | ||||
if self._hgpath is not None: | ||||
return self._hgpath | ||||
cmd = '%s -c "import mercurial; print (mercurial.__path__[0])"' | ||||
pipe = os.popen(cmd % PYTHON) | ||||
try: | ||||
self._hgpath = pipe.read().strip() | ||||
finally: | ||||
pipe.close() | ||||
return self._hgpath | ||||
|
r21354 | |||
|
r21378 | def _outputcoverage(self): | ||
|
r21536 | """Produce code coverage output.""" | ||
|
r21356 | vlog('# Producing coverage report') | ||
|
r21534 | os.chdir(self._pythondir) | ||
|
r21356 | |||
def covrun(*args): | ||||
cmd = 'coverage %s' % ' '.join(args) | ||||
vlog('# Running: %s' % cmd) | ||||
os.system(cmd) | ||||
covrun('-c') | ||||
omit = ','.join(os.path.join(x, '*') for x in | ||||
|
r21534 | [self._bindir, self._testdir]) | ||
|
r21356 | covrun('-i', '-r', '"--omit=%s"' % omit) # report | ||
if self.options.htmlcov: | ||||
|
r21534 | htmldir = os.path.join(self._testdir, 'htmlcov') | ||
|
r21356 | covrun('-i', '-b', '"--directory=%s"' % htmldir, | ||
'"--omit=%s"' % omit) | ||||
if self.options.annotate: | ||||
|
r21534 | adir = os.path.join(self._testdir, 'annotated') | ||
|
r21356 | if not os.path.isdir(adir): | ||
os.mkdir(adir) | ||||
covrun('-i', '-a', '"--directory=%s"' % adir, '"--omit=%s"' % omit) | ||||
|
r21365 | def _findprogram(self, program): | ||
"""Search PATH for a executable program""" | ||||
for p in os.environ.get('PATH', os.defpath).split(os.pathsep): | ||||
name = os.path.join(p, program) | ||||
if os.name == 'nt' or os.access(name, os.X_OK): | ||||
return name | ||||
return None | ||||
|
r21374 | def _checktools(self): | ||
|
r21536 | """Ensure tools required to run tests are present.""" | ||
|
r21365 | for p in self.REQUIREDTOOLS: | ||
if os.name == 'nt' and not p.endswith('.exe'): | ||||
p += '.exe' | ||||
found = self._findprogram(p) | ||||
if found: | ||||
vlog("# Found prerequisite", p, "at", found) | ||||
else: | ||||
print "WARNING: Did not find prerequisite tool: %s " % p | ||||
|
r13347 | if __name__ == '__main__': | ||
|
r21377 | runner = TestRunner() | ||
|
r22120 | |||
try: | ||||
import msvcrt | ||||
msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY) | ||||
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY) | ||||
msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY) | ||||
except ImportError: | ||||
pass | ||||
|
r21377 | sys.exit(runner.run(sys.argv[1:])) | ||