run-tests.py
709 lines
| 21.9 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> | ||||
# | ||||
# This software may be used and distributed according to the terms | ||||
# of the GNU General Public License, incorporated herein by reference. | ||||
|
r2571 | import difflib | ||
import errno | ||||
import optparse | ||||
import os | ||||
|
r7813 | try: | ||
import subprocess | ||||
subprocess.Popen # trigger ImportError early | ||||
closefds = os.name == 'posix' | ||||
def Popen4(cmd, bufsize=-1): | ||||
p = subprocess.Popen(cmd, shell=True, bufsize=bufsize, | ||||
close_fds=closefds, | ||||
stdin=subprocess.PIPE, stdout=subprocess.PIPE, | ||||
stderr=subprocess.STDOUT) | ||||
p.fromchild = p.stdout | ||||
p.tochild = p.stdin | ||||
p.childerr = p.stderr | ||||
return p | ||||
except ImportError: | ||||
subprocess = None | ||||
from popen2 import Popen4 | ||||
|
r2571 | import shutil | ||
import signal | ||||
import sys | ||||
|
r2110 | import tempfile | ||
|
r2571 | import time | ||
|
r2110 | |||
|
r5685 | # reserved exit code to skip test (used by hghave) | ||
|
r4881 | SKIPPED_STATUS = 80 | ||
|
r5685 | SKIPPED_PREFIX = 'skipped: ' | ||
|
r8060 | FAILED_PREFIX = 'hghave check failed: ' | ||
|
r4881 | |||
|
r4365 | required_tools = ["python", "diff", "grep", "unzip", "gunzip", "bunzip2", "sed"] | ||
|
r2110 | |||
|
r6366 | defaults = { | ||
'jobs': ('HGTEST_JOBS', 1), | ||||
'timeout': ('HGTEST_TIMEOUT', 180), | ||||
'port': ('HGTEST_PORT', 20059), | ||||
} | ||||
|
r8091 | # globals set by parse_args() (ugh) | ||
verbose = False | ||||
nodiff = False | ||||
coverage = False | ||||
python = None | ||||
|
r3300 | |||
|
r8091 | def parse_args(): | ||
parser = optparse.OptionParser("%prog [options] [tests]") | ||||
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") | ||||
parser.add_option("-f", "--first", action="store_true", | ||||
help="exit on the first test failure") | ||||
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", | ||||
help="keep temporary directory after running tests" | ||||
" (best used with --tmpdir)") | ||||
parser.add_option("-R", "--restart", action="store_true", | ||||
help="restart at last error") | ||||
parser.add_option("-p", "--port", type="int", | ||||
help="port on which servers should listen" | ||||
" (default: $%s or %d)" % defaults['port']) | ||||
parser.add_option("-r", "--retest", action="store_true", | ||||
help="retest failed tests") | ||||
parser.add_option("-s", "--cover_stdlib", action="store_true", | ||||
help="print a test coverage report inc. standard libraries") | ||||
parser.add_option("-t", "--timeout", type="int", | ||||
help="kill errant tests after TIMEOUT seconds" | ||||
" (default: $%s or %d)" % defaults['timeout']) | ||||
parser.add_option("--tmpdir", type="string", | ||||
help="run tests in the given temporary directory") | ||||
parser.add_option("-v", "--verbose", action="store_true", | ||||
help="output verbose messages") | ||||
parser.add_option("-n", "--nodiff", action="store_true", | ||||
help="skip showing test changes") | ||||
parser.add_option("--with-hg", type="string", | ||||
help="test existing install at given location") | ||||
parser.add_option("--pure", action="store_true", | ||||
help="use pure Python code instead of C extensions") | ||||
|
r2110 | |||
|
r8091 | for option, default in defaults.items(): | ||
defaults[option] = int(os.environ.get(*default)) | ||||
parser.set_defaults(**defaults) | ||||
(options, args) = parser.parse_args() | ||||
global verbose, nodiff, coverage, python | ||||
verbose = options.verbose | ||||
nodiff = options.nodiff | ||||
coverage = options.cover or options.cover_stdlib or options.annotate | ||||
python = sys.executable | ||||
if options.jobs < 1: | ||||
print >> sys.stderr, 'ERROR: -j/--jobs must be positive' | ||||
sys.exit(1) | ||||
if options.interactive and options.jobs > 1: | ||||
print '(--interactive overrides --jobs)' | ||||
options.jobs = 1 | ||||
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) | ||||
|
r2110 | def vlog(*msg): | ||
if verbose: | ||||
for m in msg: | ||||
print m, | ||||
|
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 | ||||
lines.append(text[i:n+1]) | ||||
i = n + 1 | ||||
|
r8060 | def parse_hghave_output(lines): | ||
'''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 | |||
|
r2110 | def show_diff(expected, output): | ||
for line in difflib.unified_diff(expected, output, | ||||
|
r2409 | "Expected output", "Test output"): | ||
|
r2247 | sys.stdout.write(line) | ||
|
r2110 | |||
def find_program(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.access(name, os.X_OK): | ||||
return name | ||||
return None | ||||
|
r2133 | def check_required_tools(): | ||
# Before we go any further, check for pre-requisite tools | ||||
# stuff from coreutils (cat, rm, etc) are not tested | ||||
for p in required_tools: | ||||
if os.name == 'nt': | ||||
p += '.exe' | ||||
found = find_program(p) | ||||
if found: | ||||
vlog("# Found prerequisite", p, "at", found) | ||||
else: | ||||
print "WARNING: Did not find prerequisite tool: "+p | ||||
|
r2110 | |||
def cleanup_exit(): | ||||
|
r6208 | if not options.keep_tmpdir: | ||
if verbose: | ||||
print "# Cleaning up HGTMP", HGTMP | ||||
shutil.rmtree(HGTMP, True) | ||||
|
r2110 | |||
|
r2570 | def use_correct_python(): | ||
# some tests run python interpreter. they must use same | ||||
# interpreter we use or bad things will happen. | ||||
exedir, exename = os.path.split(sys.executable) | ||||
if exename == 'python': | ||||
path = find_program('python') | ||||
if os.path.dirname(path) == exedir: | ||||
return | ||||
vlog('# Making python executable in test path use correct Python') | ||||
my_python = os.path.join(BINDIR, 'python') | ||||
try: | ||||
os.symlink(sys.executable, my_python) | ||||
except AttributeError: | ||||
# windows fallback | ||||
shutil.copyfile(sys.executable, my_python) | ||||
shutil.copymode(sys.executable, my_python) | ||||
|
r3223 | |||
|
r2133 | def install_hg(): | ||
|
r4319 | global python | ||
|
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 | ||
os.chdir(os.path.join(os.path.dirname(sys.argv[0]), '..')) | ||||
|
r7723 | cmd = ('%s setup.py %s clean --all' | ||
|
r7139 | ' install --force --prefix="%s" --install-lib="%s"' | ||
|
r5189 | ' --install-scripts="%s" >%s 2>&1' | ||
|
r7723 | % (sys.executable, pure, INST, PYTHONDIR, BINDIR, installerrs)) | ||
|
r2133 | vlog("# Running", cmd) | ||
if os.system(cmd) == 0: | ||||
if not verbose: | ||||
os.remove(installerrs) | ||||
else: | ||||
f = open(installerrs) | ||||
for line in f: | ||||
print line, | ||||
f.close() | ||||
sys.exit(1) | ||||
os.chdir(TESTDIR) | ||||
|
r2110 | |||
|
r2133 | os.environ["PATH"] = "%s%s%s" % (BINDIR, os.pathsep, os.environ["PATH"]) | ||
|
r5251 | |||
|
r5268 | pydir = os.pathsep.join([PYTHONDIR, TESTDIR]) | ||
|
r5251 | pythonpath = os.environ.get("PYTHONPATH") | ||
if pythonpath: | ||||
|
r5268 | pythonpath = pydir + os.pathsep + pythonpath | ||
|
r5251 | else: | ||
|
r5268 | pythonpath = pydir | ||
|
r5251 | os.environ["PYTHONPATH"] = pythonpath | ||
|
r2110 | |||
|
r2570 | use_correct_python() | ||
|
r6982 | global hgpkg | ||
hgpkg = _hgpath() | ||||
|
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) | ||||
|
r2144 | if coverage: | ||
vlog("# Installing coverage wrapper") | ||||
os.environ['COVERAGE_FILE'] = COVERAGE_FILE | ||||
if os.path.exists(COVERAGE_FILE): | ||||
os.unlink(COVERAGE_FILE) | ||||
# Create a wrapper script to invoke hg via coverage.py | ||||
|
r2146 | os.rename(os.path.join(BINDIR, "hg"), os.path.join(BINDIR, "_hg.py")) | ||
|
r2144 | f = open(os.path.join(BINDIR, 'hg'), 'w') | ||
f.write('#!' + sys.executable + '\n') | ||||
|
r4633 | f.write('import sys, os; os.execv(sys.executable, [sys.executable, ' | ||
'"%s", "-x", "%s"] + sys.argv[1:])\n' % | ||||
(os.path.join(TESTDIR, 'coverage.py'), | ||||
os.path.join(BINDIR, '_hg.py'))) | ||||
|
r2144 | f.close() | ||
os.chmod(os.path.join(BINDIR, 'hg'), 0700) | ||||
|
r4319 | python = '"%s" "%s" -x' % (sys.executable, | ||
os.path.join(TESTDIR,'coverage.py')) | ||||
|
r2144 | |||
|
r8092 | def _hgpath(): | ||
cmd = '%s -c "import mercurial; print mercurial.__path__[0]"' | ||||
hgpath = os.popen(cmd % python) | ||||
path = hgpath.read().strip() | ||||
hgpath.close() | ||||
return path | ||||
|
r2144 | def output_coverage(): | ||
|
r2145 | vlog("# Producing coverage report") | ||
omit = [BINDIR, TESTDIR, PYTHONDIR] | ||||
if not options.cover_stdlib: | ||||
# Exclude as system paths (ignoring empty strings seen on win) | ||||
|
r2146 | omit += [x for x in sys.path if x != ''] | ||
|
r2145 | omit = ','.join(omit) | ||
os.chdir(PYTHONDIR) | ||||
|
r4318 | cmd = '"%s" "%s" -i -r "--omit=%s"' % ( | ||
|
r2145 | sys.executable, os.path.join(TESTDIR, 'coverage.py'), omit) | ||
vlog("# Running: "+cmd) | ||||
os.system(cmd) | ||||
if options.annotate: | ||||
adir = os.path.join(TESTDIR, 'annotated') | ||||
if not os.path.isdir(adir): | ||||
os.mkdir(adir) | ||||
|
r4318 | cmd = '"%s" "%s" -i -a "--directory=%s" "--omit=%s"' % ( | ||
|
r2145 | sys.executable, os.path.join(TESTDIR, 'coverage.py'), | ||
adir, omit) | ||||
|
r2144 | vlog("# Running: "+cmd) | ||
os.system(cmd) | ||||
|
r2571 | class Timeout(Exception): | ||
pass | ||||
def alarmed(signum, frame): | ||||
raise Timeout | ||||
|
r2247 | def run(cmd): | ||
|
r2110 | """Run command in a sub-process, capturing the output (stdout and stderr). | ||
Return the exist code, and output.""" | ||||
# TODO: Use subprocess.Popen if we're running on Python 2.4 | ||||
|
r7792 | if os.name == 'nt' or sys.platform.startswith('java'): | ||
|
r2110 | tochild, fromchild = os.popen4(cmd) | ||
tochild.close() | ||||
output = fromchild.read() | ||||
ret = fromchild.close() | ||||
if ret == None: | ||||
ret = 0 | ||||
else: | ||||
|
r7813 | proc = Popen4(cmd) | ||
|
r2571 | try: | ||
output = '' | ||||
proc.tochild.close() | ||||
output = proc.fromchild.read() | ||||
ret = proc.wait() | ||||
|
r4880 | if os.WIFEXITED(ret): | ||
ret = os.WEXITSTATUS(ret) | ||||
|
r2571 | except Timeout: | ||
vlog('# Process %d timed out - killing it' % proc.pid) | ||||
os.kill(proc.pid, signal.SIGTERM) | ||||
ret = proc.wait() | ||||
if ret == 0: | ||||
ret = signal.SIGTERM << 8 | ||||
|
r5078 | output += ("\n### Abort: timeout after %d seconds.\n" | ||
% options.timeout) | ||||
|
r2247 | return ret, splitnewlines(output) | ||
|
r2110 | |||
|
r6244 | def run_one(test, skips, fails): | ||
|
r2710 | '''tristate output: | ||
None -> skipped | ||||
True -> passed | ||||
False -> failed''' | ||||
|
r5470 | def skip(msg): | ||
if not verbose: | ||||
skips.append((test, msg)) | ||||
else: | ||||
print "\nSkipping %s: %s" % (test, msg) | ||||
return None | ||||
|
r6244 | def fail(msg): | ||
fails.append((test, msg)) | ||||
|
r7343 | if not nodiff: | ||
print "\nERROR: %s %s" % (test, msg) | ||||
|
r6244 | return None | ||
|
r2110 | vlog("# Test", test) | ||
|
r2989 | # create a fresh hgrc | ||
hgrc = file(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('debugrawcommit = -d "0 0"\n') | ||||
hgrc.write('tag = -d "0 0"\n') | ||||
|
r2989 | hgrc.close() | ||
|
r2110 | err = os.path.join(TESTDIR, test+".err") | ||
ref = os.path.join(TESTDIR, test+".out") | ||||
|
r4320 | testpath = os.path.join(TESTDIR, test) | ||
|
r2110 | |||
if os.path.exists(err): | ||||
os.remove(err) # Remove any previous output files | ||||
# Make a tmp subdirectory to work in | ||||
tmpd = os.path.join(HGTMP, test) | ||||
os.mkdir(tmpd) | ||||
os.chdir(tmpd) | ||||
|
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': | ||
|
r4320 | cmd = '%s "%s"' % (python, testpath) | ||
|
r2710 | elif lctest.endswith('.bat'): | ||
# do not run batch scripts on non-windows | ||||
if os.name != 'nt': | ||||
|
r5470 | return skip("batch script") | ||
|
r2710 | # To reliably get the error code from batch files on WinXP, | ||
# the "cmd /c call" prefix is needed. Grrr | ||||
|
r4320 | cmd = 'cmd /c call "%s"' % testpath | ||
|
r2710 | else: | ||
# do not run shell scripts on windows | ||||
if os.name == 'nt': | ||||
|
r5470 | return skip("shell script") | ||
|
r2710 | # do not try to run non-executable programs | ||
|
r7144 | if not os.path.exists(testpath): | ||
return fail("does not exist") | ||||
elif not os.access(testpath, os.X_OK): | ||||
|
r5470 | return skip("not executable") | ||
|
r4320 | cmd = '"%s"' % testpath | ||
|
r2110 | |||
|
r2571 | if options.timeout > 0: | ||
signal.alarm(options.timeout) | ||||
|
r2110 | vlog("# Running", cmd) | ||
ret, out = run(cmd) | ||||
vlog("# Ret was:", ret) | ||||
|
r2571 | if options.timeout > 0: | ||
signal.alarm(0) | ||||
|
r7343 | mark = '.' | ||
|
r4881 | skipped = (ret == SKIPPED_STATUS) | ||
|
r2213 | # If reference output file exists, check test output against it | ||
if os.path.exists(ref): | ||||
f = open(ref, "r") | ||||
|
r2247 | ref_out = splitnewlines(f.read()) | ||
|
r2213 | f.close() | ||
|
r2246 | else: | ||
|
r2703 | ref_out = [] | ||
|
r4881 | if skipped: | ||
|
r7343 | mark = 's' | ||
|
r8060 | missing, failed = parse_hghave_output(out) | ||
|
r4881 | if not missing: | ||
missing = ['irrelevant'] | ||||
|
r8060 | if failed: | ||
fail("hghave failed checking for %s" % failed[-1]) | ||||
skipped = False | ||||
else: | ||||
skip(missing[-1]) | ||||
|
r6383 | elif out != ref_out: | ||
|
r7343 | mark = '!' | ||
|
r6383 | if ret: | ||
fail("output changed and returned error code %d" % ret) | ||||
else: | ||||
fail("output changed") | ||||
|
r7529 | if not nodiff: | ||
show_diff(ref_out, out) | ||||
|
r6383 | ret = 1 | ||
|
r4881 | elif ret: | ||
|
r7343 | mark = '!' | ||
|
r6244 | fail("returned error code %d" % ret) | ||
|
r2110 | |||
|
r5470 | if not verbose: | ||
|
r7343 | sys.stdout.write(mark) | ||
|
r5470 | sys.stdout.flush() | ||
|
r5081 | if ret != 0 and not skipped: | ||
|
r4881 | # Save errors to a file for diagnosis | ||
|
r2247 | f = open(err, "wb") | ||
|
r2110 | for line in out: | ||
f.write(line) | ||||
f.close() | ||||
|
r2571 | # Kill off any leftover daemon processes | ||
try: | ||||
fp = file(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 | ||||
|
r2110 | os.chdir(TESTDIR) | ||
|
r6208 | if not options.keep_tmpdir: | ||
|
r6209 | shutil.rmtree(tmpd, True) | ||
|
r4881 | if skipped: | ||
return None | ||||
|
r2110 | return ret == 0 | ||
|
r8091 | (options, args) = parse_args() | ||
|
r5384 | if not options.child: | ||
os.umask(022) | ||||
|
r2133 | |||
|
r5384 | check_required_tools() | ||
|
r2133 | |||
# Reset some environment variables to well-known values so that | ||||
# the tests produce repeatable output. | ||||
os.environ['LANG'] = os.environ['LC_ALL'] = 'C' | ||||
os.environ['TZ'] = 'GMT' | ||||
|
r5779 | os.environ["EMAIL"] = "Foo Bar <foo.bar@example.com>" | ||
|
r7448 | os.environ['CDPATH'] = '' | ||
|
r2133 | |||
TESTDIR = os.environ["TESTDIR"] = os.getcwd() | ||||
|
r7730 | HGTMP = os.environ['HGTMP'] = os.path.realpath(tempfile.mkdtemp('', 'hgtests.', | ||
options.tmpdir)) | ||||
|
r5384 | DAEMON_PIDS = None | ||
HGRCPATH = None | ||||
|
r2571 | |||
|
r4365 | os.environ["HGEDITOR"] = sys.executable + ' -c "import sys; sys.exit(0)"' | ||
|
r6004 | os.environ["HGMERGE"] = "internal:merge" | ||
|
r4365 | os.environ["HGUSER"] = "test" | ||
os.environ["HGENCODING"] = "ascii" | ||||
os.environ["HGENCODINGMODE"] = "strict" | ||||
|
r5384 | os.environ["HGPORT"] = str(options.port) | ||
os.environ["HGPORT1"] = str(options.port + 1) | ||||
os.environ["HGPORT2"] = str(options.port + 2) | ||||
|
r4365 | |||
|
r5384 | if options.with_hg: | ||
INST = options.with_hg | ||||
else: | ||||
INST = os.path.join(HGTMP, "install") | ||||
|
r7785 | BINDIR = os.environ["BINDIR"] = os.path.join(INST, "bin") | ||
|
r2144 | PYTHONDIR = os.path.join(INST, "lib", "python") | ||
COVERAGE_FILE = os.path.join(TESTDIR, ".coverage") | ||||
|
r6982 | expecthg = os.path.join(HGTMP, 'install', 'lib', 'python', 'mercurial') | ||
hgpkg = None | ||||
|
r5384 | def run_children(tests): | ||
if not options.with_hg: | ||||
install_hg() | ||||
|
r7018 | if hgpkg != expecthg: | ||
print '# Testing unexpected mercurial: %s' % hgpkg | ||||
|
r5384 | |||
optcopy = dict(options.__dict__) | ||||
optcopy['jobs'] = 1 | ||||
optcopy['with_hg'] = INST | ||||
opts = [] | ||||
for opt, value in optcopy.iteritems(): | ||||
name = '--' + opt.replace('_', '-') | ||||
if value is True: | ||||
opts.append(name) | ||||
elif value is not None: | ||||
opts.append(name + '=' + str(value)) | ||||
tests.reverse() | ||||
jobs = [[] for j in xrange(options.jobs)] | ||||
while tests: | ||||
for j in xrange(options.jobs): | ||||
if not tests: break | ||||
jobs[j].append(tests.pop()) | ||||
fps = {} | ||||
for j in xrange(len(jobs)): | ||||
job = jobs[j] | ||||
if not job: | ||||
continue | ||||
rfd, wfd = os.pipe() | ||||
childopts = ['--child=%d' % wfd, '--port=%d' % (options.port + j * 3)] | ||||
cmdline = [python, sys.argv[0]] + opts + childopts + job | ||||
vlog(' '.join(cmdline)) | ||||
fps[os.spawnvp(os.P_NOWAIT, cmdline[0], cmdline)] = os.fdopen(rfd, 'r') | ||||
os.close(wfd) | ||||
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() | ||
test, skip, fail = map(int, l[:3]) | ||||
|
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 | |||
for s in skips: | ||||
print "Skipped %s: %s" % (s[0], s[1]) | ||||
|
r6244 | for s in fails: | ||
print "Failed %s: %s" % (s[0], s[1]) | ||||
|
r6982 | |||
if hgpkg != expecthg: | ||||
print '# Tested unexpected mercurial: %s' % hgpkg | ||||
|
r5470 | print "# Ran %d tests, %d skipped, %d failed." % ( | ||
|
r5384 | tested, skipped, failed) | ||
sys.exit(failures != 0) | ||||
def run_tests(tests): | ||||
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: | ||
|
r5384 | if not options.with_hg: | ||
install_hg() | ||||
|
r2133 | |||
|
r7018 | if hgpkg != expecthg: | ||
print '# Testing unexpected mercurial: %s' % hgpkg | ||||
|
r6982 | |||
|
r2571 | if options.timeout > 0: | ||
try: | ||||
signal.signal(signal.SIGALRM, alarmed) | ||||
vlog('# Running tests with %d-second timeout' % | ||||
options.timeout) | ||||
except AttributeError: | ||||
print 'WARNING: cannot run tests with timeouts' | ||||
options.timeout = 0 | ||||
|
r3625 | tested = 0 | ||
|
r2258 | failed = 0 | ||
|
r2710 | skipped = 0 | ||
|
r2110 | |||
|
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 | |||
|
r5470 | skips = [] | ||
|
r6244 | fails = [] | ||
|
r3625 | for test in tests: | ||
if options.retest and not os.path.exists(test + ".err"): | ||||
skipped += 1 | ||||
continue | ||||
|
r6244 | ret = run_one(test, skips, fails) | ||
|
r3625 | if ret is None: | ||
skipped += 1 | ||||
elif not ret: | ||||
|
r3626 | if options.interactive: | ||
print "Accept this change? [n] ", | ||||
answer = sys.stdin.readline().strip() | ||||
if answer.lower() in "y yes".split(): | ||||
|
r5800 | rename(test + ".err", test + ".out") | ||
|
r3626 | tested += 1 | ||
|
r6343 | fails.pop() | ||
|
r3626 | continue | ||
|
r3625 | failed += 1 | ||
if options.first: | ||||
break | ||||
tested += 1 | ||||
|
r5384 | if options.child: | ||
fp = os.fdopen(options.child, 'w') | ||||
fp.write('%d\n%d\n%d\n' % (tested, skipped, failed)) | ||||
|
r5470 | for s in skips: | ||
|
r5760 | fp.write("%s %s\n" % s) | ||
|
r6244 | for s in fails: | ||
fp.write("%s %s\n" % s) | ||||
|
r5384 | fp.close() | ||
else: | ||||
|
r5470 | |||
for s in skips: | ||||
print "Skipped %s: %s" % s | ||||
|
r6244 | for s in fails: | ||
print "Failed %s: %s" % s | ||||
|
r6982 | if hgpkg != expecthg: | ||
print '# Tested unexpected mercurial: %s' % hgpkg | ||||
|
r5470 | print "# Ran %d tests, %d skipped, %d failed." % ( | ||
|
r5384 | tested, skipped, failed) | ||
|
r2258 | if coverage: | ||
output_coverage() | ||||
except KeyboardInterrupt: | ||||
failed = True | ||||
print "\ninterrupted!" | ||||
|
r5384 | |||
if failed: | ||||
sys.exit(1) | ||||
if len(args) == 0: | ||||
args = os.listdir(".") | ||||
args.sort() | ||||
tests = [] | ||||
for test in args: | ||||
if (test.startswith("test-") and '~' not in test and | ||||
('.' not in test or test.endswith('.py') or | ||||
test.endswith('.bat'))): | ||||
tests.append(test) | ||||
vlog("# Using TESTDIR", TESTDIR) | ||||
vlog("# Using HGTMP", HGTMP) | ||||
try: | ||||
if len(tests) > 1 and options.jobs > 1: | ||||
run_children(tests) | ||||
else: | ||||
run_tests(tests) | ||||
|
r2133 | finally: | ||
cleanup_exit() | ||||