run-tests.py
1274 lines
| 41.7 KiB
| text/x-python
|
PythonLexer
/ tests / run-tests.py
|
r2110 | #!/usr/bin/env python | ||
# | ||||
# run-tests.py - Run a set of tests on Mercurial | ||||
# | ||||
# Copyright 2006 Matt Mackall <mpm@selenic.com> | ||||
# | ||||
|
r8225 | # This software may be used and distributed according to the terms of the | ||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r2110 | |||
|
r8674 | # Modifying this script is tricky because it has many modes: | ||
# - serial (default) vs parallel (-jN, N > 1) | ||||
# - no coverage (default) vs coverage (-c, -C, -s) | ||||
# - temp install (default) vs specific hg script (--with-hg, --local) | ||||
# - tests are a mix of shell scripts and Python scripts | ||||
# | ||||
# If you change this script, it is recommended that you ensure you | ||||
# haven't broken it by running it in various modes with a representative | ||||
# sample of test scripts. For example: | ||||
|
r8843 | # | ||
|
r8674 | # 1) serial, no coverage, temp install: | ||
# ./run-tests.py test-s* | ||||
# 2) serial, no coverage, local hg: | ||||
# ./run-tests.py --local test-s* | ||||
# 3) serial, coverage, temp install: | ||||
# ./run-tests.py -c test-s* | ||||
# 4) serial, coverage, local hg: | ||||
# ./run-tests.py -c --local test-s* # unsupported | ||||
# 5) parallel, no coverage, temp install: | ||||
# ./run-tests.py -j2 test-s* | ||||
# 6) parallel, no coverage, local hg: | ||||
# ./run-tests.py -j2 --local test-s* | ||||
# 7) parallel, coverage, temp install: | ||||
# ./run-tests.py -j2 -c test-s* # currently broken | ||||
|
r9899 | # 8) parallel, coverage, local install: | ||
|
r8674 | # ./run-tests.py -j2 -c --local test-s* # unsupported (and broken) | ||
|
r9899 | # 9) parallel, custom tmp dir: | ||
# ./run-tests.py -j2 --tmpdir /tmp/myhgtests | ||||
|
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 | ||
|
r11741 | import re | ||
|
r14000 | import threading | ||
|
r2110 | |||
|
r14019 | processlock = threading.Lock() | ||
|
r8280 | closefds = os.name == 'posix' | ||
|
r14019 | def Popen4(cmd, wd, timeout): | ||
processlock.acquire() | ||||
|
r14340 | p = subprocess.Popen(cmd, shell=True, bufsize=-1, cwd=wd, | ||
|
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: | ||||
time.sleep(1) | ||||
p.timeout = True | ||||
if p.returncode is None: | ||||
|
r14821 | terminate(p) | ||
|
r14001 | threading.Thread(target=t).start() | ||
|
r8280 | return p | ||
|
r5685 | # reserved exit code to skip test (used by hghave) | ||
|
r4881 | SKIPPED_STATUS = 80 | ||
|
r5685 | SKIPPED_PREFIX = 'skipped: ' | ||
|
r8060 | FAILED_PREFIX = 'hghave check failed: ' | ||
|
r15448 | PYTHON = sys.executable.replace('\\', '/') | ||
|
r10758 | IMPL_PATH = 'PYTHONPATH' | ||
if 'java' in sys.platform: | ||||
IMPL_PATH = 'JYTHONPATH' | ||||
|
r4881 | |||
|
r8097 | requiredtools = ["python", "diff", "grep", "unzip", "gunzip", "bunzip2", "sed"] | ||
|
r2110 | |||
|
r6366 | defaults = { | ||
'jobs': ('HGTEST_JOBS', 1), | ||||
'timeout': ('HGTEST_TIMEOUT', 180), | ||||
'port': ('HGTEST_PORT', 20059), | ||||
|
r14202 | 'shell': ('HGTEST_SHELL', '/bin/sh'), | ||
|
r6366 | } | ||
|
r14493 | def parselistfiles(files, listtype, warn=True): | ||
entries = dict() | ||||
for filename in files: | ||||
try: | ||||
path = os.path.expanduser(os.path.expandvars(filename)) | ||||
f = open(path, "r") | ||||
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 | ||||
|
r8097 | def parseargs(): | ||
|
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") | ||||
|
r8091 | parser.add_option("-C", "--annotate", action="store_true", | ||
help="output files annotated with coverage") | ||||
parser.add_option("--child", type="int", | ||||
help="run as child process, summary to given fd") | ||||
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" | ||||
" rather than capturing and diff'ing it (disables timeout)") | ||||
|
r8091 | parser.add_option("-f", "--first", action="store_true", | ||
help="exit on the first test failure") | ||||
|
r11039 | parser.add_option("--inotify", action="store_true", | ||
help="enable inotify extension when running tests") | ||||
|
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") | ||||
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']) | ||||
|
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']) | ||||
|
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") | ||||
|
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') | ||||
|
r2110 | |||
|
r14201 | for option, (envvar, default) in defaults.items(): | ||
defaults[option] = type(default)(os.environ.get(envvar, default)) | ||||
|
r8091 | parser.set_defaults(**defaults) | ||
(options, args) = parser.parse_args() | ||||
|
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: | ||
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') | ||||
if not os.access(hgbin, os.X_OK): | ||||
parser.error('--local specified, but %r not found or not executable' | ||||
% hgbin) | ||||
options.with_hg = hgbin | ||||
|
r10648 | options.anycoverage = options.cover or options.annotate | ||
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 | |||
global vlog | ||||
|
r8095 | if options.verbose: | ||
|
r8671 | if options.jobs > 1 or options.child is not None: | ||
pid = "[%d]" % os.getpid() | ||||
else: | ||||
pid = None | ||||
|
r8095 | def vlog(*msg): | ||
|
r14018 | iolock.acquire() | ||
|
r8671 | if pid: | ||
print pid, | ||||
|
r8095 | for m in msg: | ||
print m, | ||||
|
r9707 | sys.stdout.flush() | ||
|
r14018 | iolock.release() | ||
|
r8095 | else: | ||
vlog = lambda *msg: None | ||||
|
r8091 | |||
|
r9394 | if options.tmpdir: | ||
options.tmpdir = os.path.expanduser(options.tmpdir) | ||||
|
r8091 | if options.jobs < 1: | ||
|
r9408 | parser.error('--jobs must be positive') | ||
|
r8091 | if options.interactive and options.jobs > 1: | ||
print '(--interactive overrides --jobs)' | ||||
options.jobs = 1 | ||||
|
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: | ||||
options.whitelisted = parselistfiles(options.whitelist, 'whitelist', | ||||
warn=options.child is None) | ||||
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) | ||||
|
r2247 | def splitnewlines(text): | ||
'''like str.splitlines, but only split on newlines. | ||||
keep line endings.''' | ||||
i = 0 | ||||
lines = [] | ||||
while True: | ||||
n = text.find('\n', i) | ||||
if n == -1: | ||||
last = text[i:] | ||||
if last: | ||||
lines.append(last) | ||||
return lines | ||||
|
r10282 | lines.append(text[i:n + 1]) | ||
|
r2247 | i = n + 1 | ||
|
r8097 | def parsehghaveoutput(lines): | ||
|
r8060 | '''Parse hghave log lines. | ||
Return tuple of lists (missing, failed): | ||||
* the missing/unknown features | ||||
* the features for which existence check failed''' | ||||
|
r4881 | missing = [] | ||
|
r8060 | failed = [] | ||
|
r4881 | for line in lines: | ||
|
r8060 | if line.startswith(SKIPPED_PREFIX): | ||
line = line.splitlines()[0] | ||||
missing.append(line[len(SKIPPED_PREFIX):]) | ||||
elif line.startswith(FAILED_PREFIX): | ||||
line = line.splitlines()[0] | ||||
failed.append(line[len(FAILED_PREFIX):]) | ||||
|
r4881 | |||
|
r8060 | return missing, failed | ||
|
r4881 | |||
|
r10088 | def showdiff(expected, output, ref, err): | ||
|
r14062 | |||
|
r10088 | for line in difflib.unified_diff(expected, output, ref, err): | ||
|
r2247 | sys.stdout.write(line) | ||
|
r2110 | |||
|
r8097 | def findprogram(program): | ||
|
r2110 | """Search PATH for a executable program""" | ||
for p in os.environ.get('PATH', os.defpath).split(os.pathsep): | ||||
name = os.path.join(p, program) | ||||
|
r14335 | if os.name == 'nt' or os.access(name, os.X_OK): | ||
|
r2110 | return name | ||
return None | ||||
|
r8097 | def checktools(): | ||
|
r2133 | # Before we go any further, check for pre-requisite tools | ||
# stuff from coreutils (cat, rm, etc) are not tested | ||||
|
r8097 | for p in requiredtools: | ||
|
r2133 | if os.name == 'nt': | ||
p += '.exe' | ||||
|
r8097 | found = findprogram(p) | ||
|
r2133 | if found: | ||
vlog("# Found prerequisite", p, "at", found) | ||||
else: | ||||
print "WARNING: Did not find prerequisite tool: "+p | ||||
|
r2110 | |||
|
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 | ||||
|
r10336 | def killdaemons(): | ||
# Kill off any leftover daemon processes | ||||
try: | ||||
fp = open(DAEMON_PIDS) | ||||
for line in fp: | ||||
try: | ||||
pid = int(line) | ||||
except ValueError: | ||||
continue | ||||
try: | ||||
os.kill(pid, 0) | ||||
vlog('# Killing daemon process %d' % pid) | ||||
os.kill(pid, signal.SIGTERM) | ||||
time.sleep(0.25) | ||||
os.kill(pid, 0) | ||||
vlog('# Daemon process %d is stuck - really killing it' % pid) | ||||
os.kill(pid, signal.SIGKILL) | ||||
except OSError, err: | ||||
if err.errno != errno.ESRCH: | ||||
raise | ||||
fp.close() | ||||
os.unlink(DAEMON_PIDS) | ||||
except IOError: | ||||
pass | ||||
|
r8097 | def cleanup(options): | ||
|
r6208 | if not options.keep_tmpdir: | ||
|
r8671 | vlog("# Cleaning up HGTMP", HGTMP) | ||
|
r6208 | shutil.rmtree(HGTMP, True) | ||
|
r2110 | |||
|
r8097 | def usecorrectpython(): | ||
|
r2570 | # some tests run python interpreter. they must use same | ||
# interpreter we use or bad things will happen. | ||||
exedir, exename = os.path.split(sys.executable) | ||||
|
r14335 | if exename in ('python', 'python.exe'): | ||
path = findprogram(exename) | ||||
|
r2570 | if os.path.dirname(path) == exedir: | ||
return | ||||
|
r14335 | else: | ||
exename = 'python' | ||||
|
r2570 | vlog('# Making python executable in test path use correct Python') | ||
|
r14335 | mypython = os.path.join(BINDIR, exename) | ||
|
r2570 | try: | ||
|
r8097 | os.symlink(sys.executable, mypython) | ||
|
r2570 | except AttributeError: | ||
# windows fallback | ||||
|
r8097 | shutil.copyfile(sys.executable, mypython) | ||
shutil.copymode(sys.executable, mypython) | ||||
|
r3223 | |||
|
r8097 | def installhg(options): | ||
|
r2133 | vlog("# Performing temporary installation of HG") | ||
installerrs = os.path.join("tests", "install.err") | ||||
|
r7723 | pure = options.pure and "--pure" or "" | ||
|
r2110 | |||
|
r5267 | # Run installer in hg root | ||
|
r8943 | script = os.path.realpath(sys.argv[0]) | ||
hgroot = os.path.dirname(os.path.dirname(script)) | ||||
os.chdir(hgroot) | ||||
|
r9905 | 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 = '' | ||||
|
r7723 | cmd = ('%s setup.py %s clean --all' | ||
|
r12502 | ' build --build-base="%s"' | ||
|
r7139 | ' install --force --prefix="%s" --install-lib="%s"' | ||
|
r10030 | ' --install-scripts="%s" %s >%s 2>&1' | ||
|
r12502 | % (sys.executable, pure, os.path.join(HGTMP, "build"), | ||
INST, PYTHONDIR, BINDIR, nohome, installerrs)) | ||||
|
r2133 | vlog("# Running", cmd) | ||
if os.system(cmd) == 0: | ||||
|
r8095 | if not options.verbose: | ||
|
r2133 | os.remove(installerrs) | ||
else: | ||||
f = open(installerrs) | ||||
for line in f: | ||||
print line, | ||||
f.close() | ||||
sys.exit(1) | ||||
os.chdir(TESTDIR) | ||||
|
r2110 | |||
|
r8097 | usecorrectpython() | ||
|
r2570 | |||
|
r7172 | vlog("# Installing dummy diffstat") | ||
f = open(os.path.join(BINDIR, 'diffstat'), 'w') | ||||
f.write('#!' + sys.executable + '\n' | ||||
'import sys\n' | ||||
'files = 0\n' | ||||
'for line in sys.stdin:\n' | ||||
' if line.startswith("diff "):\n' | ||||
' files += 1\n' | ||||
'sys.stdout.write("files patched: %d\\n" % files)\n') | ||||
f.close() | ||||
os.chmod(os.path.join(BINDIR, 'diffstat'), 0700) | ||||
|
r9028 | if options.py3k_warnings and not options.anycoverage: | ||
vlog("# Updating hg command to enable Py3k Warnings switch") | ||||
f = open(os.path.join(BINDIR, 'hg'), 'r') | ||||
lines = [line.rstrip() for line in f] | ||||
lines[0] += ' -3' | ||||
f.close() | ||||
f = open(os.path.join(BINDIR, 'hg'), 'w') | ||||
for line in lines: | ||||
f.write(line + '\n') | ||||
f.close() | ||||
|
r14336 | hgbat = os.path.join(BINDIR, 'hg.bat') | ||
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' | ||||
|
r8095 | if options.anycoverage: | ||
|
r10648 | custom = os.path.join(TESTDIR, 'sitecustomize.py') | ||
target = os.path.join(PYTHONDIR, 'sitecustomize.py') | ||||
vlog('# Installing coverage trigger to %s' % target) | ||||
shutil.copyfile(custom, target) | ||||
rc = os.path.join(TESTDIR, '.coveragerc') | ||||
vlog('# Installing coverage rc to %s' % rc) | ||||
os.environ['COVERAGE_PROCESS_START'] = rc | ||||
fn = os.path.join(INST, '..', '.coverage') | ||||
os.environ['COVERAGE_FILE'] = fn | ||||
|
r8092 | |||
|
r8097 | def outputcoverage(options): | ||
|
r8620 | |||
vlog('# Producing coverage report') | ||||
os.chdir(PYTHONDIR) | ||||
def covrun(*args): | ||||
|
r10648 | cmd = 'coverage %s' % ' '.join(args) | ||
|
r8620 | vlog('# Running: %s' % cmd) | ||
os.system(cmd) | ||||
|
r10648 | if options.child: | ||
return | ||||
|
r8620 | |||
|
r10648 | covrun('-c') | ||
|
r15858 | omit = ','.join(os.path.join(x, '*') for x in [BINDIR, TESTDIR]) | ||
|
r8620 | covrun('-i', '-r', '"--omit=%s"' % omit) # report | ||
|
r2145 | if options.annotate: | ||
adir = os.path.join(TESTDIR, 'annotated') | ||||
if not os.path.isdir(adir): | ||||
os.mkdir(adir) | ||||
|
r8620 | covrun('-i', '-a', '"--directory=%s"' % adir, '"--omit=%s"' % omit) | ||
|
r2144 | |||
|
r14019 | def pytest(test, wd, options, replacements): | ||
|
r11740 | py3kswitch = options.py3k_warnings and ' -3' or '' | ||
cmd = '%s%s "%s"' % (PYTHON, py3kswitch, test) | ||||
vlog("# Running", cmd) | ||||
|
r14019 | return run(cmd, wd, options, replacements) | ||
|
r11740 | |||
|
r14019 | def shtest(test, wd, options, replacements): | ||
|
r15517 | cmd = '%s "%s"' % (options.shell, test) | ||
|
r11740 | vlog("# Running", cmd) | ||
|
r14019 | return run(cmd, wd, options, replacements) | ||
|
r11740 | |||
|
r12941 | needescape = re.compile(r'[\x00-\x08\x0b-\x1f\x7f-\xff]').search | ||
escapesub = re.compile(r'[\x00-\x08\x0b-\x1f\\\x7f-\xff]').sub | ||||
escapemap = dict((chr(i), r'\x%02x' % i) for i in range(256)) | ||||
escapemap.update({'\\': '\\\\', '\r': r'\r'}) | ||||
def escapef(m): | ||||
return escapemap[m.group(0)] | ||||
def stringescape(s): | ||||
return escapesub(escapef, s) | ||||
|
r15414 | def rematch(el, l): | ||
try: | ||||
# ensure that the regex matches to the end of the string | ||||
return re.match(el + r'\Z', l) | ||||
except re.error: | ||||
# el is an invalid regex | ||||
return False | ||||
def globmatch(el, l): | ||||
|
r15447 | # The only supported special characters are * and ? plus / which also | ||
# matches \ on windows. Escaping of these caracters is supported. | ||||
|
r15414 | i, n = 0, len(el) | ||
res = '' | ||||
while i < n: | ||||
c = el[i] | ||||
i += 1 | ||||
|
r15447 | if c == '\\' and el[i] in '*?\\/': | ||
|
r15414 | res += el[i - 1:i + 1] | ||
i += 1 | ||||
elif c == '*': | ||||
res += '.*' | ||||
elif c == '?': | ||||
res += '.' | ||||
|
r15447 | elif c == '/' and os.name == 'nt': | ||
res += '[/\\\\]' | ||||
|
r15414 | else: | ||
res += re.escape(c) | ||||
return rematch(res, l) | ||||
|
r15415 | def linematch(el, l): | ||
if el == l: # perfect match (fast) | ||||
return True | ||||
if (el and | ||||
(el.endswith(" (re)\n") and rematch(el[:-6] + '\n', l) or | ||||
el.endswith(" (glob)\n") and globmatch(el[:-8] + '\n', l) or | ||||
|
r15435 | el.endswith(" (esc)\n") and | ||
|
r15449 | (el[:-7].decode('string-escape') + '\n' == l or | ||
el[:-7].decode('string-escape').replace('\r', '') + | ||||
'\n' == l and os.name == 'nt'))): | ||||
|
r15415 | return True | ||
return False | ||||
|
r14019 | def tsttest(test, wd, options, replacements): | ||
|
r15413 | # 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 | ||||
|
r11741 | salt = "SALT" + str(time.time()) | ||
|
r15434 | def addsalt(line, inpython): | ||
if inpython: | ||||
script.append('%s %d 0\n' % (salt, line)) | ||||
else: | ||||
script.append('echo %s %s $?\n' % (salt, line)) | ||||
|
r11741 | |||
|
r15413 | # 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 = {} | ||||
|
r11741 | pos = prepos = -1 | ||
|
r15413 | |||
# Expected shellscript output | ||||
|
r11741 | expected = {} | ||
|
r15413 | |||
# We keep track of whether or not we're in a Python block so we | ||||
# can generate the surrounding doctest magic | ||||
|
r15412 | inpython = False | ||
|
r15413 | |||
|
r15416 | f = open(test) | ||
t = f.readlines() | ||||
f.close() | ||||
script = [] | ||||
|
r15569 | if os.getenv('MSYSTEM'): | ||
script.append('alias pwd="pwd -W"\n') | ||||
|
r15412 | for n, l in enumerate(t): | ||
|
r12934 | if not l.endswith('\n'): | ||
l += '\n' | ||||
|
r15413 | if l.startswith(' >>> '): # python inlines | ||
|
r15434 | after.setdefault(pos, []).append(l) | ||
prepos = pos | ||||
pos = n | ||||
|
r15412 | if not inpython: | ||
# we've just entered a Python block, add the header | ||||
inpython = True | ||||
|
r15434 | addsalt(prepos, False) # make sure we report the exit code | ||
|
r15412 | script.append('%s -m heredoctest <<EOF\n' % PYTHON) | ||
|
r15434 | addsalt(n, True) | ||
script.append(l[2:]) | ||||
if l.startswith(' ... '): # python inlines | ||||
|
r15412 | after.setdefault(prepos, []).append(l) | ||
script.append(l[2:]) | ||||
elif l.startswith(' $ '): # commands | ||||
if inpython: | ||||
script.append("EOF\n") | ||||
inpython = False | ||||
|
r11741 | after.setdefault(pos, []).append(l) | ||
prepos = pos | ||||
pos = n | ||||
|
r15434 | addsalt(n, False) | ||
|
r11741 | script.append(l[4:]) | ||
elif l.startswith(' > '): # continuations | ||||
after.setdefault(prepos, []).append(l) | ||||
script.append(l[4:]) | ||||
elif l.startswith(' '): # results | ||||
|
r15434 | # queue up a list of expected results | ||
expected.setdefault(pos, []).append(l[2:]) | ||||
|
r11741 | else: | ||
|
r15412 | if inpython: | ||
script.append("EOF\n") | ||||
inpython = False | ||||
|
r11741 | # non-command/result - queue up for merged output | ||
after.setdefault(pos, []).append(l) | ||||
|
r15413 | if inpython: | ||
script.append("EOF\n") | ||||
|
r15434 | addsalt(n + 1, False) | ||
|
r12316 | |||
|
r15416 | # Write out the script and execute it | ||
|
r11741 | fd, name = tempfile.mkstemp(suffix='hg-tst') | ||
try: | ||||
for l in script: | ||||
os.write(fd, l) | ||||
os.close(fd) | ||||
|
r15450 | cmd = '%s "%s"' % (options.shell, name) | ||
|
r11741 | vlog("# Running", cmd) | ||
|
r14019 | exitcode, output = run(cmd, wd, options, replacements) | ||
|
r12573 | # do not merge output if skipped, return hghave message instead | ||
|
r13002 | # similarly, with --debug, output is None | ||
if exitcode == SKIPPED_STATUS or output is None: | ||||
|
r12573 | return exitcode, output | ||
|
r11741 | finally: | ||
os.remove(name) | ||||
|
r15413 | # Merge the script output back into a unified test | ||
|
r11741 | pos = -1 | ||
postout = [] | ||||
|
r12316 | ret = 0 | ||
|
r11741 | for n, l in enumerate(output): | ||
|
r12940 | lout, lcmd = l, None | ||
if salt in l: | ||||
lout, lcmd = l.split(salt, 1) | ||||
if lout: | ||||
if lcmd: | ||||
|
r15413 | # output block had no trailing newline, clean up | ||
|
r12940 | lout += ' (no-eol)\n' | ||
|
r15413 | # find the expected output at the current position | ||
|
r12940 | el = None | ||
if pos in expected and expected[pos]: | ||||
el = expected[pos].pop(0) | ||||
|
r15415 | if linematch(el, lout): | ||
postout.append(" " + el) | ||||
|
r12940 | else: | ||
|
r12941 | if needescape(lout): | ||
lout = stringescape(lout.rstrip('\n')) + " (esc)\n" | ||||
|
r12940 | postout.append(" " + lout) # let diff deal with it | ||
if lcmd: | ||||
|
r12316 | # add on last return code | ||
|
r12940 | ret = int(lcmd.split()[1]) | ||
|
r12316 | if ret != 0: | ||
postout.append(" [%s]\n" % ret) | ||||
|
r11741 | if pos in after: | ||
|
r15413 | # merge in non-active test bits | ||
|
r11741 | postout += after.pop(pos) | ||
|
r12940 | pos = int(lcmd.split()[0]) | ||
|
r11741 | |||
if pos in after: | ||||
postout += after.pop(pos) | ||||
return exitcode, postout | ||||
|
r13348 | wifexited = getattr(os, "WIFEXITED", lambda x: False) | ||
|
r14019 | def run(cmd, wd, options, replacements): | ||
|
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.""" | ||
|
r2110 | # TODO: Use subprocess.Popen if we're running on Python 2.4 | ||
|
r9707 | if options.debug: | ||
|
r14339 | proc = subprocess.Popen(cmd, shell=True, cwd=wd) | ||
|
r9707 | ret = proc.wait() | ||
return (ret, None) | ||||
|
r14338 | proc = Popen4(cmd, wd, options.timeout) | ||
def cleanup(): | ||||
|
r14821 | terminate(proc) | ||
|
r14338 | ret = proc.wait() | ||
if ret == 0: | ||||
ret = signal.SIGTERM << 8 | ||||
killdaemons() | ||||
return ret | ||||
output = '' | ||||
proc.tochild.close() | ||||
|
r10336 | |||
|
r14338 | try: | ||
output = proc.fromchild.read() | ||||
except KeyboardInterrupt: | ||||
vlog('# Handling keyboard interrupt') | ||||
cleanup() | ||||
raise | ||||
|
r10336 | |||
|
r14338 | ret = proc.wait() | ||
if wifexited(ret): | ||||
ret = os.WEXITSTATUS(ret) | ||||
|
r14001 | |||
|
r14338 | if proc.timeout: | ||
ret = 'timeout' | ||||
|
r14001 | |||
|
r14338 | if ret: | ||
killdaemons() | ||||
|
r14001 | |||
|
r12639 | for s, r in replacements: | ||
|
r12895 | output = re.sub(s, r, output) | ||
|
r2247 | return ret, splitnewlines(output) | ||
|
r2110 | |||
|
r14000 | def runone(options, test): | ||
|
r2710 | '''tristate output: | ||
None -> skipped | ||||
True -> passed | ||||
False -> failed''' | ||||
|
r14002 | global results, resultslock, iolock | ||
|
r14000 | |||
|
r13989 | testpath = os.path.join(TESTDIR, test) | ||
|
r14000 | def result(l, e): | ||
resultslock.acquire() | ||||
results[l].append(e) | ||||
resultslock.release() | ||||
|
r5470 | def skip(msg): | ||
|
r8095 | if not options.verbose: | ||
|
r14000 | result('s', (test, msg)) | ||
|
r5470 | else: | ||
|
r14003 | iolock.acquire() | ||
|
r10088 | print "\nSkipping %s: %s" % (testpath, msg) | ||
|
r14003 | iolock.release() | ||
|
r5470 | return None | ||
|
r13988 | def fail(msg, ret): | ||
|
r8095 | if not options.nodiff: | ||
|
r14003 | iolock.acquire() | ||
|
r10088 | print "\nERROR: %s %s" % (testpath, msg) | ||
|
r14003 | iolock.release() | ||
|
r13999 | if (not ret and options.interactive | ||
and os.path.exists(testpath + ".err")): | ||||
|
r14003 | iolock.acquire() | ||
|
r13988 | print "Accept this change? [n] ", | ||
answer = sys.stdin.readline().strip() | ||||
|
r14003 | iolock.release() | ||
|
r13988 | if answer.lower() in "y yes".split(): | ||
if test.endswith(".t"): | ||||
|
r13999 | rename(testpath + ".err", testpath) | ||
|
r13988 | else: | ||
|
r13999 | rename(testpath + ".err", testpath + ".out") | ||
|
r14867 | result('p', test) | ||
|
r13988 | return | ||
|
r14000 | result('f', (test, msg)) | ||
|
r13994 | |||
def success(): | ||||
|
r14000 | result('p', test) | ||
|
r13994 | |||
def ignore(msg): | ||||
|
r14000 | result('i', (test, msg)) | ||
|
r6244 | |||
|
r14264 | if (os.path.basename(test).startswith("test-") and '~' not in test and | ||
|
r13989 | ('.' not in test or test.endswith('.py') or | ||
test.endswith('.bat') or test.endswith('.t'))): | ||||
if not os.path.exists(test): | ||||
skip("doesn't exist") | ||||
return None | ||||
else: | ||||
|
r14598 | vlog('# Test file', test, 'not supported, ignoring') | ||
|
r13989 | return None # not a supported test, don't record | ||
|
r14493 | if not (options.whitelisted and test in options.whitelisted): | ||
if options.blacklist and test in options.blacklist: | ||||
skip("blacklisted") | ||||
return None | ||||
|
r13993 | |||
|
r14493 | if options.retest and not os.path.exists(test + ".err"): | ||
ignore("not retesting") | ||||
return None | ||||
|
r13993 | |||
|
r14493 | if options.keywords: | ||
fp = open(test) | ||||
t = fp.read().lower() + test.lower() | ||||
fp.close() | ||||
for k in options.keywords.lower().split(): | ||||
if k in t: | ||||
break | ||||
else: | ||||
ignore("doesn't match keyword") | ||||
return None | ||||
|
r13991 | |||
|
r2110 | vlog("# Test", test) | ||
|
r2989 | # create a fresh hgrc | ||
|
r9031 | hgrc = open(HGRCPATH, 'w+') | ||
|
r4529 | hgrc.write('[ui]\n') | ||
hgrc.write('slash = True\n') | ||||
|
r5524 | hgrc.write('[defaults]\n') | ||
hgrc.write('backout = -d "0 0"\n') | ||||
hgrc.write('commit = -d "0 0"\n') | ||||
hgrc.write('tag = -d "0 0"\n') | ||||
|
r9958 | if options.inotify: | ||
hgrc.write('[extensions]\n') | ||||
hgrc.write('inotify=\n') | ||||
hgrc.write('[inotify]\n') | ||||
hgrc.write('pidfile=%s\n' % DAEMON_PIDS) | ||||
|
r10013 | hgrc.write('appendpid=True\n') | ||
|
r14134 | if options.extra_config_opt: | ||
for opt in options.extra_config_opt: | ||||
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)) | ||||
|
r2989 | hgrc.close() | ||
|
r2110 | ref = os.path.join(TESTDIR, test+".out") | ||
|
r10406 | err = os.path.join(TESTDIR, test+".err") | ||
|
r2110 | if os.path.exists(err): | ||
os.remove(err) # Remove any previous output files | ||||
|
r4321 | try: | ||
tf = open(testpath) | ||||
firstline = tf.readline().rstrip() | ||||
tf.close() | ||||
except: | ||||
firstline = '' | ||||
|
r2710 | lctest = test.lower() | ||
|
r2110 | |||
|
r4321 | if lctest.endswith('.py') or firstline == '#!/usr/bin/env python': | ||
|
r11740 | runner = pytest | ||
|
r11741 | elif lctest.endswith('.t'): | ||
runner = tsttest | ||||
ref = testpath | ||||
|
r2710 | else: | ||
# do not try to run non-executable programs | ||||
|
r12678 | if not os.access(testpath, os.X_OK): | ||
|
r5470 | return skip("not executable") | ||
|
r11740 | runner = shtest | ||
|
r2110 | |||
|
r10406 | # Make a tmp subdirectory to work in | ||
|
r13764 | testtmp = os.environ["TESTTMP"] = os.environ["HOME"] = \ | ||
|
r15448 | os.path.join(HGTMP, os.path.basename(test)).replace('\\', '/') | ||
|
r13764 | |||
|
r15449 | replacements = [ | ||
|
r12895 | (r':%s\b' % options.port, ':$HGPORT'), | ||
(r':%s\b' % (options.port + 1), ':$HGPORT1'), | ||||
(r':%s\b' % (options.port + 2), ':$HGPORT2'), | ||||
|
r15449 | ] | ||
if os.name == 'nt': | ||||
replacements.append((r'\r\n', '\n')) | ||||
|
r15451 | replacements.append( | ||
(''.join(c.isalpha() and '[%s%s]' % (c.lower(), c.upper()) or | ||||
c in '/\\' and r'[/\\]' or | ||||
c.isdigit() and c or | ||||
'\\' + c | ||||
for c in testtmp), '$TESTTMP')) | ||||
else: | ||||
replacements.append((re.escape(testtmp), '$TESTTMP')) | ||||
|
r15449 | |||
os.mkdir(testtmp) | ||||
ret, out = runner(testpath, testtmp, options, replacements) | ||||
|
r2110 | vlog("# Ret was:", ret) | ||
|
r7343 | mark = '.' | ||
|
r4881 | skipped = (ret == SKIPPED_STATUS) | ||
|
r11040 | |||
|
r9707 | # If we're not in --debug mode and reference output file exists, | ||
# check test output against it. | ||||
if options.debug: | ||||
|
r13031 | refout = None # to match "out is None" | ||
|
r9707 | elif os.path.exists(ref): | ||
|
r2213 | f = open(ref, "r") | ||
|
r15412 | refout = list(splitnewlines(f.read())) | ||
|
r2213 | f.close() | ||
|
r2246 | else: | ||
|
r8097 | refout = [] | ||
|
r9707 | |||
|
r11040 | if (ret != 0 or out != refout) and not skipped and not options.debug: | ||
# Save errors to a file for diagnosis | ||||
f = open(err, "wb") | ||||
for line in out: | ||||
f.write(line) | ||||
f.close() | ||||
|
r4881 | if skipped: | ||
|
r7343 | mark = 's' | ||
|
r9707 | if out is None: # debug mode: nothing to parse | ||
missing = ['unknown'] | ||||
failed = None | ||||
else: | ||||
missing, failed = parsehghaveoutput(out) | ||||
|
r4881 | if not missing: | ||
missing = ['irrelevant'] | ||||
|
r8060 | if failed: | ||
|
r13988 | fail("hghave failed checking for %s" % failed[-1], ret) | ||
|
r8060 | skipped = False | ||
else: | ||||
skip(missing[-1]) | ||||
|
r14001 | elif ret == 'timeout': | ||
mark = 't' | ||||
fail("timed out", ret) | ||||
|
r8097 | elif out != refout: | ||
|
r7343 | mark = '!' | ||
|
r14006 | if not options.nodiff: | ||
|
r14002 | iolock.acquire() | ||
|
r11040 | if options.view: | ||
os.system("%s %s %s" % (options.view, ref, err)) | ||||
else: | ||||
showdiff(refout, out, ref, err) | ||||
|
r14002 | iolock.release() | ||
|
r14006 | if ret: | ||
fail("output changed and returned error code %d" % ret, ret) | ||||
else: | ||||
fail("output changed", ret) | ||||
|
r6383 | ret = 1 | ||
|
r4881 | elif ret: | ||
|
r7343 | mark = '!' | ||
|
r13988 | fail("returned error code %d" % ret, ret) | ||
|
r14037 | else: | ||
success() | ||||
|
r2110 | |||
|
r8095 | if not options.verbose: | ||
|
r14002 | iolock.acquire() | ||
|
r7343 | sys.stdout.write(mark) | ||
|
r5470 | sys.stdout.flush() | ||
|
r14002 | iolock.release() | ||
|
r5470 | |||
|
r10336 | killdaemons() | ||
|
r2571 | |||
|
r6208 | if not options.keep_tmpdir: | ||
|
r12639 | shutil.rmtree(testtmp, True) | ||
|
r4881 | if skipped: | ||
return None | ||||
|
r2110 | return ret == 0 | ||
|
r8672 | _hgpath = None | ||
def _gethgpath(): | ||||
"""Return the path to the mercurial package that is actually found by | ||||
the current Python interpreter.""" | ||||
global _hgpath | ||||
if _hgpath is not None: | ||||
return _hgpath | ||||
cmd = '%s -c "import mercurial; print mercurial.__path__[0]"' | ||||
pipe = os.popen(cmd % PYTHON) | ||||
try: | ||||
_hgpath = pipe.read().strip() | ||||
finally: | ||||
pipe.close() | ||||
return _hgpath | ||||
def _checkhglib(verb): | ||||
"""Ensure that the 'mercurial' package imported by python is | ||||
|
r8673 | the one we expect it to be. If not, print a warning to stderr.""" | ||
expecthg = os.path.join(PYTHONDIR, 'mercurial') | ||||
|
r8672 | actualhg = _gethgpath() | ||
|
r14263 | if os.path.abspath(actualhg) != os.path.abspath(expecthg): | ||
|
r8673 | sys.stderr.write('warning: %s with unexpected mercurial lib: %s\n' | ||
' (expected %s)\n' | ||||
% (verb, actualhg, expecthg)) | ||||
|
r8672 | |||
def runchildren(options, tests): | ||||
|
r8674 | if INST: | ||
|
r8107 | installhg(options) | ||
|
r8672 | _checkhglib("Testing") | ||
|
r5384 | |||
optcopy = dict(options.__dict__) | ||||
optcopy['jobs'] = 1 | ||||
|
r14447 | |||
|
r14493 | # Because whitelist has to override keyword matches, we have to | ||
# actually load the whitelist in the children as well, so we allow | ||||
# the list of whitelist files to pass through and be parsed in the | ||||
# children, but not the dict of whitelisted tests resulting from | ||||
# the parse, used here to override blacklisted tests. | ||||
whitelist = optcopy['whitelisted'] or [] | ||||
del optcopy['whitelisted'] | ||||
|
r14447 | blacklist = optcopy['blacklist'] or [] | ||
|
r10904 | del optcopy['blacklist'] | ||
|
r14447 | blacklisted = [] | ||
|
r8674 | if optcopy['with_hg'] is None: | ||
optcopy['with_hg'] = os.path.join(BINDIR, "hg") | ||||
|
r10648 | optcopy.pop('anycoverage', None) | ||
|
r5384 | opts = [] | ||
for opt, value in optcopy.iteritems(): | ||||
name = '--' + opt.replace('_', '-') | ||||
if value is True: | ||||
opts.append(name) | ||||
|
r14192 | elif isinstance(value, list): | ||
for v in value: | ||||
opts.append(name + '=' + str(v)) | ||||
|
r5384 | elif value is not None: | ||
opts.append(name + '=' + str(value)) | ||||
tests.reverse() | ||||
jobs = [[] for j in xrange(options.jobs)] | ||||
while tests: | ||||
|
r8161 | for job in jobs: | ||
|
r10282 | if not tests: | ||
break | ||||
|
r14447 | test = tests.pop() | ||
|
r14493 | if test not in whitelist and test in blacklist: | ||
|
r14447 | blacklisted.append(test) | ||
else: | ||||
job.append(test) | ||||
|
r5384 | fps = {} | ||
|
r10336 | |||
|
r8161 | for j, job in enumerate(jobs): | ||
|
r5384 | if not job: | ||
continue | ||||
rfd, wfd = os.pipe() | ||||
childopts = ['--child=%d' % wfd, '--port=%d' % (options.port + j * 3)] | ||||
|
r9899 | childtmp = os.path.join(HGTMP, 'child%d' % j) | ||
childopts += ['--tmpdir', childtmp] | ||||
|
r8096 | cmdline = [PYTHON, sys.argv[0]] + opts + childopts + job | ||
|
r5384 | vlog(' '.join(cmdline)) | ||
fps[os.spawnvp(os.P_NOWAIT, cmdline[0], cmdline)] = os.fdopen(rfd, 'r') | ||||
os.close(wfd) | ||||
|
r10336 | signal.signal(signal.SIGINT, signal.SIG_IGN) | ||
|
r5384 | failures = 0 | ||
tested, skipped, failed = 0, 0, 0 | ||||
|
r5470 | skips = [] | ||
|
r6244 | fails = [] | ||
|
r5384 | while fps: | ||
pid, status = os.wait() | ||||
fp = fps.pop(pid) | ||||
|
r5470 | l = fp.read().splitlines() | ||
|
r10336 | try: | ||
test, skip, fail = map(int, l[:3]) | ||||
except ValueError: | ||||
test, skip, fail = 0, 0, 0 | ||||
|
r6244 | split = -fail or len(l) | ||
for s in l[3:split]: | ||||
|
r5470 | skips.append(s.split(" ", 1)) | ||
|
r6244 | for s in l[split:]: | ||
fails.append(s.split(" ", 1)) | ||||
|
r5384 | tested += test | ||
skipped += skip | ||||
failed += fail | ||||
vlog('pid %d exited, status %d' % (pid, status)) | ||||
failures |= status | ||||
|
r5470 | |||
|
r14447 | skipped += len(blacklisted) | ||
|
r9580 | if not options.noskips: | ||
for s in skips: | ||||
print "Skipped %s: %s" % (s[0], s[1]) | ||||
|
r14447 | for s in blacklisted: | ||
print "Skipped %s: blacklisted" % s | ||||
|
r6244 | for s in fails: | ||
print "Failed %s: %s" % (s[0], s[1]) | ||||
|
r6982 | |||
|
r8672 | _checkhglib("Tested") | ||
|
r5470 | print "# Ran %d tests, %d skipped, %d failed." % ( | ||
|
r5384 | tested, skipped, failed) | ||
|
r10648 | |||
if options.anycoverage: | ||||
outputcoverage(options) | ||||
|
r5384 | sys.exit(failures != 0) | ||
|
r14000 | results = dict(p=[], f=[], s=[], i=[]) | ||
resultslock = threading.Lock() | ||||
|
r14002 | iolock = threading.Lock() | ||
|
r14000 | |||
|
r13995 | def runqueue(options, tests, results): | ||
for test in tests: | ||||
|
r14000 | ret = runone(options, test) | ||
|
r13995 | if options.first and ret is not None and not ret: | ||
break | ||||
|
r8672 | def runtests(options, tests): | ||
|
r5384 | global DAEMON_PIDS, HGRCPATH | ||
DAEMON_PIDS = os.environ["DAEMON_PIDS"] = os.path.join(HGTMP, 'daemon.pids') | ||||
HGRCPATH = os.environ["HGRCPATH"] = os.path.join(HGTMP, '.hgrc') | ||||
|
r2258 | try: | ||
|
r8674 | if INST: | ||
|
r8097 | installhg(options) | ||
|
r8672 | _checkhglib("Testing") | ||
|
r6982 | |||
|
r3625 | if 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 | ||||
|
r2133 | |||
|
r13995 | runqueue(options, tests, results) | ||
|
r3625 | |||
|
r13994 | failed = len(results['f']) | ||
tested = len(results['p']) + failed | ||||
skipped = len(results['s']) | ||||
ignored = len(results['i']) | ||||
|
r5384 | if options.child: | ||
fp = os.fdopen(options.child, 'w') | ||||
fp.write('%d\n%d\n%d\n' % (tested, skipped, failed)) | ||||
|
r13994 | for s in results['s']: | ||
|
r5760 | fp.write("%s %s\n" % s) | ||
|
r13994 | for s in results['f']: | ||
|
r6244 | fp.write("%s %s\n" % s) | ||
|
r5384 | fp.close() | ||
else: | ||||
|
r5470 | |||
|
r13994 | for s in results['s']: | ||
|
r5470 | print "Skipped %s: %s" % s | ||
|
r13994 | for s in results['f']: | ||
|
r6244 | print "Failed %s: %s" % s | ||
|
r8672 | _checkhglib("Tested") | ||
|
r5470 | print "# Ran %d tests, %d skipped, %d failed." % ( | ||
|
r13994 | tested, skipped + ignored, failed) | ||
|
r5384 | |||
|
r8095 | if options.anycoverage: | ||
|
r8097 | outputcoverage(options) | ||
|
r2258 | except KeyboardInterrupt: | ||
failed = True | ||||
print "\ninterrupted!" | ||||
|
r5384 | |||
|
r13994 | if failed: | ||
|
r5384 | sys.exit(1) | ||
|
r8094 | def main(): | ||
|
r8097 | (options, args) = parseargs() | ||
|
r8094 | if not options.child: | ||
os.umask(022) | ||||
|
r8093 | |||
|
r8097 | checktools() | ||
|
r8093 | |||
|
r12677 | if len(args) == 0: | ||
args = os.listdir(".") | ||||
args.sort() | ||||
|
r13989 | tests = args | ||
|
r12677 | |||
|
r8094 | # Reset some environment variables to well-known values so that | ||
# the tests produce repeatable output. | ||||
|
r9931 | os.environ['LANG'] = os.environ['LC_ALL'] = os.environ['LANGUAGE'] = 'C' | ||
|
r8094 | os.environ['TZ'] = 'GMT' | ||
os.environ["EMAIL"] = "Foo Bar <foo.bar@example.com>" | ||||
os.environ['CDPATH'] = '' | ||||
|
r9913 | os.environ['COLUMNS'] = '80' | ||
|
r10750 | os.environ['GREP_OPTIONS'] = '' | ||
|
r10154 | os.environ['http_proxy'] = '' | ||
|
r15344 | os.environ['no_proxy'] = '' | ||
os.environ['NO_PROXY'] = '' | ||||
|
r8093 | |||
|
r10902 | # unset env related to hooks | ||
for k in os.environ.keys(): | ||||
if k.startswith('HG_'): | ||||
|
r10923 | # can't remove on solaris | ||
os.environ[k] = '' | ||||
|
r10902 | del os.environ[k] | ||
|
r8094 | global TESTDIR, HGTMP, INST, BINDIR, PYTHONDIR, COVERAGE_FILE | ||
TESTDIR = os.environ["TESTDIR"] = os.getcwd() | ||||
|
r9706 | if options.tmpdir: | ||
options.keep_tmpdir = True | ||||
tmpdir = 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. | ||||
sys.exit("error: temp dir %r already exists" % tmpdir) | ||||
# 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: | ||||
tmpdir = tempfile.mkdtemp('', 'hgtests.') | ||||
HGTMP = os.environ['HGTMP'] = os.path.realpath(tmpdir) | ||||
|
r8094 | DAEMON_PIDS = None | ||
HGRCPATH = None | ||||
|
r8093 | |||
|
r8094 | os.environ["HGEDITOR"] = sys.executable + ' -c "import sys; sys.exit(0)"' | ||
os.environ["HGMERGE"] = "internal:merge" | ||||
os.environ["HGUSER"] = "test" | ||||
os.environ["HGENCODING"] = "ascii" | ||||
os.environ["HGENCODINGMODE"] = "strict" | ||||
os.environ["HGPORT"] = str(options.port) | ||||
os.environ["HGPORT1"] = str(options.port + 1) | ||||
os.environ["HGPORT2"] = str(options.port + 2) | ||||
|
r8093 | |||
|
r8094 | if options.with_hg: | ||
|
r8674 | INST = None | ||
BINDIR = os.path.dirname(os.path.realpath(options.with_hg)) | ||||
# 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. | ||||
PYTHONDIR = BINDIR | ||||
|
r8094 | else: | ||
INST = os.path.join(HGTMP, "install") | ||||
|
r8674 | BINDIR = os.environ["BINDIR"] = os.path.join(INST, "bin") | ||
PYTHONDIR = os.path.join(INST, "lib", "python") | ||||
os.environ["BINDIR"] = BINDIR | ||||
os.environ["PYTHON"] = PYTHON | ||||
if not options.child: | ||||
path = [BINDIR] + os.environ["PATH"].split(os.pathsep) | ||||
os.environ["PATH"] = os.pathsep.join(path) | ||||
|
r8724 | # 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 | ||||
pypath = [PYTHONDIR, TESTDIR] | ||||
|
r8687 | # 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.) | ||||
|
r10758 | oldpypath = os.environ.get(IMPL_PATH) | ||
|
r8724 | if oldpypath: | ||
pypath.append(oldpypath) | ||||
|
r10758 | os.environ[IMPL_PATH] = os.pathsep.join(pypath) | ||
|
r8674 | |||
|
r8094 | COVERAGE_FILE = os.path.join(TESTDIR, ".coverage") | ||
|
r8093 | |||
|
r8094 | vlog("# Using TESTDIR", TESTDIR) | ||
vlog("# Using HGTMP", HGTMP) | ||||
|
r8674 | vlog("# Using PATH", os.environ["PATH"]) | ||
|
r10758 | vlog("# Using", IMPL_PATH, os.environ[IMPL_PATH]) | ||
|
r5384 | |||
|
r8094 | try: | ||
if len(tests) > 1 and options.jobs > 1: | ||||
|
r8672 | runchildren(options, tests) | ||
|
r8094 | else: | ||
|
r8672 | runtests(options, tests) | ||
|
r8094 | finally: | ||
|
r10336 | time.sleep(1) | ||
|
r8097 | cleanup(options) | ||
|
r5384 | |||
|
r13347 | if __name__ == '__main__': | ||
main() | ||||