Command line options:
--v: verbose -- run tests in verbose mode with output to stdout
--q: quiet -- don't print anything except if a test fails
--g: generate -- write the output file for a test instead of comparing it
--x: exclude -- arguments are tests to *exclude*
--s: single -- run only a single test (see below)
--r: random -- randomize test execution order
--f: fromfile -- read names of tests to run from a file (see below)
--l: findleaks -- if GC is available detect tests that leak memory
--u: use -- specify which special resource intensive tests to run
--h: help -- print this text and exit
--t: threshold -- call gc.set_threshold(N)
--T: coverage -- turn on code coverage using the trace module
--L: runleaks -- run the leaks(1) command just before exit
+-v: verbose -- run tests in verbose mode with output to stdout
+-q: quiet -- don't print anything except if a test fails
+-g: generate -- write the output file for a test instead of comparing it
+-x: exclude -- arguments are tests to *exclude*
+-s: single -- run only a single test (see below)
+-r: random -- randomize test execution order
+-f: fromfile -- read names of tests to run from a file (see below)
+-l: findleaks -- if GC is available detect tests that leak memory
+-u: use -- specify which special resource intensive tests to run
+-h: help -- print this text and exit
+-t: threshold -- call gc.set_threshold(N)
+-T: coverage -- turn on code coverage using the trace module
+-L: runleaks -- run the leaks(1) command just before exit
+-R: huntrleaks -- search for reference leaks (needs debug build, v. slow)
If non-option arguments are present, they are names for tests to run,
unless -x is given, in which case they are names for tests not to run.
leaks(1) is available on Mac OS X and presumably on some other
FreeBSD-derived systems.
+-R runs each test several times and examines sys.gettotalrefcount() to
+see if the test appears to be leaking references. The argument should
+be of the form stab:run:fname where 'stab' is the number of times the
+test is run to let gettotalrefcount settle down, 'run' is the number
+of times further it is run and 'fname' is the name of the file the
+reports are written to. These parameters all have defaults (5, 4 and
+"reflog.txt" respectively), so the minimal invocation is '-R ::'.
+
-u is used to specify which special resource intensive tests to run,
such as those requiring large file support or network connectivity.
The argument is a comma-separated list of words indicating the
import getopt
import random
import warnings
+import sre
import cStringIO
import traceback
def main(tests=None, testdir=None, verbose=0, quiet=False, generate=False,
exclude=False, single=False, randomize=False, fromfile=None,
- findleaks=False, use_resources=None, trace=False, runleaks=False):
+ findleaks=False, use_resources=None, trace=False, runleaks=False,
+ huntrleaks=False):
"""Execute a test suite.
This also parses command-line options and modifies its behavior
test_support.record_original_stdout(sys.stdout)
try:
- opts, args = getopt.getopt(sys.argv[1:], 'hvgqxsrf:lu:t:TL',
+ opts, args = getopt.getopt(sys.argv[1:], 'hvgqxsrf:lu:t:TLR:',
['help', 'verbose', 'quiet', 'generate',
'exclude', 'single', 'random', 'fromfile',
'findleaks', 'use=', 'threshold=', 'trace',
- 'runleaks'
+ 'runleaks', 'huntrleaks='
])
except getopt.error, msg:
usage(2, msg)
gc.set_threshold(int(a))
elif o in ('-T', '--coverage'):
trace = True
+ elif o in ('-R', '--huntrleaks'):
+ huntrleaks = a.split(':')
+ if len(huntrleaks) != 3:
+ print a, huntrleaks
+ usage(2, '-R takes three colon-separated arguments')
+ if len(huntrleaks[0]) == 0:
+ huntrleaks[0] = 5
+ else:
+ huntrleaks[0] = int(huntrleaks[0])
+ if len(huntrleaks[1]) == 0:
+ huntrleaks[1] = 4
+ else:
+ huntrleaks[1] = int(huntrleaks[1])
+ if len(huntrleaks[2]) == 0:
+ huntrleaks[2] = "reflog.txt"
elif o in ('-u', '--use'):
u = [x.lower() for x in a.split(',')]
for r in u:
tracer.runctx('runtest(test, generate, verbose, quiet, testdir)',
globals=globals(), locals=vars())
else:
- ok = runtest(test, generate, verbose, quiet, testdir)
+ ok = runtest(test, generate, verbose, quiet, testdir, huntrleaks)
if ok > 0:
good.append(test)
elif ok == 0:
tests.sort()
return stdtests + tests
-def runtest(test, generate, verbose, quiet, testdir=None):
+def runtest(test, generate, verbose, quiet, testdir=None, huntrleaks=False):
"""Run a single test.
test -- the name of the test
generate -- if true, generate output, instead of running the test
cfp = None
else:
cfp = cStringIO.StringIO()
+ if huntrleaks:
+ refrep = open(huntrleaks[2], "a")
try:
save_stdout = sys.stdout
try:
indirect_test = getattr(the_module, "test_main", None)
if indirect_test is not None:
indirect_test()
+ if huntrleaks:
+ # This code *is* hackish and inelegant, yes.
+ # But it seems to do the job.
+ import copy_reg
+ fs = warnings.filters[:]
+ ps = copy_reg.dispatch_table.copy()
+ pic = sys.path_importer_cache.copy()
+ import gc
+ def cleanup():
+ import _strptime, urlparse, warnings, dircache
+ from distutils.dir_util import _path_created
+ _path_created.clear()
+ warnings.filters[:] = fs
+ gc.collect()
+ sre.purge()
+ _strptime._regex_cache.clear()
+ urlparse.clear_cache()
+ copy_reg.dispatch_table.clear()
+ copy_reg.dispatch_table.update(ps)
+ sys.path_importer_cache.clear()
+ sys.path_importer_cache.update(pic)
+ dircache.reset()
+ if indirect_test:
+ def run_the_test():
+ indirect_test()
+ else:
+ def run_the_test():
+ reload(the_module)
+ deltas = []
+ repcount = huntrleaks[0] + huntrleaks[1]
+ print >> sys.stderr, "beginning", repcount, "repetitions"
+ print >> sys.stderr, \
+ ("1234567890"*(repcount//10 + 1))[:repcount]
+ for i in range(repcount):
+ rc = sys.gettotalrefcount()
+ run_the_test()
+ sys.stderr.write('.')
+ cleanup()
+ deltas.append(sys.gettotalrefcount() - rc - 2)
+ print >>sys.stderr
+ if max(map(abs, deltas[-huntrleaks[1]:])) > 0:
+ print >>refrep, test, 'leaked', \
+ deltas[-huntrleaks[1]:], 'references'
+ # The end of the huntrleaks hackishness.
finally:
sys.stdout = save_stdout
except test_support.ResourceDenied, msg:
fp.close()
else:
expected = test + "\n"
- if output == expected:
+ if output == expected or huntrleaks:
return 1
print "test", test, "produced unexpected output:"
sys.stdout.flush()
projects / python / commitdiff