This will find all modules whose name is "test_*" in the test
directory, and run them. Various command line options provide
-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
-D: coverdir -- Directory where coverage files are put
-N: nocoverdir -- Put coverage files alongside modules
-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.
If no test names are given, all tests are run.
-v is incompatible with -g and does not compare test output files.
-T turns on code coverage tracing with the trace module.
-D specifies the directory where coverage files are put.
-N Put coverage files alongside modules.
-s means to run only a single test and exit. This is useful when
doing memory analysis on the Python interpreter (which tend to consume
too many resources to run the full regression test non-stop). The
file /tmp/pynexttest is read to find the next test to run. If this
file is missing, the first test_*.py file in testdir or on the command
line is used. (actually tempfile.gettempdir() is used instead of
-f reads the names of tests from the file given as f's argument, one
or more test names per line. Whitespace is ignored. Blank lines and
lines beginning with '#' are ignored. This is especially useful for
whittling down failures involving interactions among tests.
-L causes the leaks(1) command to be run just before exit if it exists.
leaks(1) is available on Mac OS X and presumably on some other
-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
resources to test. Currently only the following are defined:
all - Enable all special resources.
audio - Tests that use the audio device. (There are known
cases of broken audio drivers that can crash Python or
curses - Tests that use curses and will modify the terminal's
largefile - It is okay to run some test that may create huge
files. These tests can take a long time and may
consume >2GB of disk space temporarily.
network - It is okay to run tests that use external network
resource, e.g. testing SSL support for sockets.
bsddb - It is okay to run the bsddb testsuite, which takes
decimal - Test the decimal module against a large suite that
verifies compliance with standards.
compiler - Test the compiler package by compiling all the source
in the standard library and test suite. This takes
subprocess Run all tests for the subprocess module.
To enable all resources except one, use '-uall,-<resource>'. For
example, to run all the tests except for the bsddb tests, give the
# I see no other way to suppress these warnings;
# putting them in test_grammar.py has no effect:
warnings
.filterwarnings("ignore", "hex/oct constants", FutureWarning
,
if sys
.maxint
> 0x7fffffff:
# Also suppress them in <string>, because for 64-bit platforms,
# that's where test_grammar.py hides them.
warnings
.filterwarnings("ignore", "hex/oct constants", FutureWarning
,
# MacOSX (a.k.a. Darwin) has a default stack size that is too small
# for deeply recursive regular expressions. We see this as crashes in
# the Python test suite when running test_re.py and test_sre.py. The
# fix is to set the stack limit to 2048.
# This approach may also be useful for other Unixy platforms that
# suffer from small default stack limits.
if sys
.platform
== 'darwin':
soft
, hard
= resource
.getrlimit(resource
.RLIMIT_STACK
)
newsoft
= min(hard
, max(soft
, 1024*2048))
resource
.setrlimit(resource
.RLIMIT_STACK
, (newsoft
, hard
))
from test
import test_support
RESOURCE_NAMES
= ('audio', 'curses', 'largefile', 'network', 'bsddb',
'decimal', 'compiler', 'subprocess')
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, coverdir
='coverage',
runleaks
=False, huntrleaks
=False):
This also parses command-line options and modifies its behavior
tests -- a list of strings containing test names (optional)
testdir -- the directory in which to look for tests (optional)
Users other than the Python test suite will certainly want to
specify testdir; if it's omitted, the directory containing the
Python test suite is searched for.
If the tests argument is omitted, the tests listed on the
command-line will be used. If that's empty, too, then all *.py
files beginning with test_ will be used.
The other default arguments (verbose, quiet, generate, exclude, single,
randomize, findleaks, use_resources, trace and coverdir) allow programmers
calling main() directly to set the values that would normally be set by
flags on the command line.
test_support
.record_original_stdout(sys
.stdout
)
opts
, args
= getopt
.getopt(sys
.argv
[1:], 'hvgqxsrf:lu:t:TD:NLR:',
['help', 'verbose', 'quiet', 'generate',
'exclude', 'single', 'random', 'fromfile',
'findleaks', 'use=', 'threshold=', 'trace',
'coverdir=', 'nocoverdir', 'runleaks',
except getopt
.error
, msg
:
if use_resources
is None:
if o
in ('-h', '--help'):
elif o
in ('-v', '--verbose'):
elif o
in ('-q', '--quiet'):
elif o
in ('-g', '--generate'):
elif o
in ('-x', '--exclude'):
elif o
in ('-s', '--single'):
elif o
in ('-r', '--randomize'):
elif o
in ('-f', '--fromfile'):
elif o
in ('-l', '--findleaks'):
elif o
in ('-L', '--runleaks'):
elif o
in ('-t', '--threshold'):
elif o
in ('-T', '--coverage'):
elif o
in ('-D', '--coverdir'):
coverdir
= os
.path
.join(os
.getcwd(), a
)
elif o
in ('-N', '--nocoverdir'):
elif o
in ('-R', '--huntrleaks'):
huntrleaks
= a
.split(':')
usage(2, '-R takes three colon-separated arguments')
if len(huntrleaks
[0]) == 0:
huntrleaks
[0] = int(huntrleaks
[0])
if len(huntrleaks
[1]) == 0:
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(',')]
use_resources
[:] = RESOURCE_NAMES
if r
not in RESOURCE_NAMES
:
usage(1, 'Invalid -u/--use option: ' + a
)
elif r
not in use_resources
:
usage(2, "-g and -v don't go together!")
usage(2, "-s and -f don't go together!")
print 'No GC available, disabling findleaks.'
# Uncomment the line below to report garbage that is not
# freeable by reference counting alone. By default only
# garbage that is not collectable by the GC is reported.
#gc.set_debug(gc.DEBUG_SAVEALL)
from tempfile
import gettempdir
filename
= os
.path
.join(gettempdir(), 'pynexttest')
guts
= line
.split() # assuming no test has whitespace in its name
if guts
and not guts
[0].startswith('#'):
args
= map(removepy
, args
)
tests
= map(removepy
, tests
)
tests
= tests
or args
or findtests(testdir
, stdtests
, nottests
)
tracer
= trace
.Trace(ignoredirs
=[sys
.prefix
, sys
.exec_prefix
],
test_support
.verbose
= verbose
# Tell tests to be moderately quiet
test_support
.use_resources
= use_resources
save_modules
= sys
.modules
.keys()
# If we're tracing code coverage, then we don't exit with status
# if on a false return value from main.
tracer
.runctx('runtest(test, generate, verbose, quiet, testdir)',
globals=globals(), locals=vars())
ok
= runtest(test
, generate
, verbose
, quiet
, testdir
, huntrleaks
)
resource_denieds
.append(test
)
print "Warning: test created", len(gc
.garbage
),
print "uncollectable object(s)."
# move the uncollectable objects somewhere so we don't see
found_garbage
.extend(gc
.garbage
)
# Unload the newly imported modules (best effort finalization)
for module
in sys
.modules
.keys():
if module
not in save_modules
and module
.startswith("test."):
test_support
.unload(module
)
# The lists won't be sorted if running with -r
if not bad
and not skipped
and len(good
) > 1:
print count(len(good
), "test"), "OK."
print "CAUTION: stdout isn't compared in verbose mode:"
print "a test that passes in verbose mode may fail without it."
print count(len(bad
), "test"), "failed:"
if skipped
and not quiet
:
print count(len(skipped
), "test"), "skipped:"
surprise
= set(skipped
) - e
.getexpected() - set(resource_denieds
)
print count(len(surprise
), "skip"), \
"unexpected on", plat
+ ":"
print "Those skips are all expected on", plat
+ "."
print "Ask someone to teach regrtest.py about which tests are"
print "expected to get skipped on", plat
+ "."
alltests
= findtests(testdir
, stdtests
, nottests
)
for i
in range(len(alltests
)):
if tests
[0] == alltests
[i
]:
if i
== len(alltests
) - 1:
fp
.write(alltests
[i
+1] + '\n')
r
.write_results(show_missing
=True, summary
=True, coverdir
=coverdir
)
os
.system("leaks %d" % os
.getpid())
def findtests(testdir
=None, stdtests
=STDTESTS
, nottests
=NOTTESTS
):
"""Return a list of all applicable test modules."""
if not testdir
: testdir
= findtestdir()
names
= os
.listdir(testdir
)
if name
[:5] == "test_" and name
[-3:] == os
.extsep
+"py":
if modname
not in stdtests
and modname
not in nottests
:
def runtest(test
, generate
, verbose
, quiet
, testdir
=None, huntrleaks
=False):
test -- the name of the test
generate -- if true, generate output, instead of running the test
and comparing it to a previously created output file
verbose -- if true, print more messages
quiet -- if true, don't print 'skipped' messages (probably redundant)
testdir -- test directory
test_support
.unload(test
)
outputdir
= os
.path
.join(testdir
, "output")
outputfile
= os
.path
.join(outputdir
, test
)
cfp
= cStringIO
.StringIO()
refrep
= open(huntrleaks
[2], "a")
print test
# Output file starts with test name
if test
.startswith('test.'):
# Always import it from the test package
the_package
= __import__(abstest
, globals(), locals(), [])
the_module
= getattr(the_package
, test
)
# Most tests run to completion simply as a side-effect of
# being imported. For the benefit of tests that can't run
# that way (like test_threaded_import), explicitly invoke
# their test_main() function (if it exists).
indirect_test
= getattr(the_module
, "test_main", None)
if indirect_test
is not None:
# This code *is* hackish and inelegant, yes.
# But it seems to do the job.
ps
= copy_reg
.dispatch_table
.copy()
pic
= sys
.path_importer_cache
.copy()
import _strptime
, urlparse
, warnings
, dircache
from distutils
.dir_util
import _path_created
_strptime
._regex
_cache
.clear()
copy_reg
.dispatch_table
.clear()
copy_reg
.dispatch_table
.update(ps
)
sys
.path_importer_cache
.clear()
sys
.path_importer_cache
.update(pic
)
repcount
= huntrleaks
[0] + huntrleaks
[1]
print >> sys
.stderr
, "beginning", repcount
, "repetitions"
("1234567890"*(repcount
//10 + 1))[:repcount
]
for i
in range(repcount
):
rc
= sys
.gettotalrefcount()
deltas
.append(sys
.gettotalrefcount() - rc
- 2)
if max(map(abs, deltas
[-huntrleaks
[1]:])) > 0:
print >>sys
.stderr
, test
, 'leaked', \
deltas
[-huntrleaks
[1]:], 'references'
print >>refrep
, test
, 'leaked', \
deltas
[-huntrleaks
[1]:], 'references'
# The end of the huntrleaks hackishness.
except test_support
.ResourceDenied
, msg
:
print test
, "skipped --", msg
except (ImportError, test_support
.TestSkipped
), msg
:
print test
, "skipped --", msg
except KeyboardInterrupt:
except test_support
.TestFailed
, msg
:
print "test", test
, "failed --", msg
type, value
= sys
.exc_info()[:2]
print "test", test
, "crashed --", str(type) + ":", value
traceback
.print_exc(file=sys
.stdout
)
if output
== test
+ "\n":
if os
.path
.exists(outputfile
):
# Write it since it already exists (and the contents
# may have changed), but let the user know it isn't
print "output file", outputfile
, \
"is no longer needed; consider removing it"
# We don't need it, so don't create it.
fp
= open(outputfile
, "w")
if os
.path
.exists(outputfile
):
fp
= open(outputfile
, "r")
if output
== expected
or huntrleaks
:
print "test", test
, "produced unexpected output:"
reportdiff(expected
, output
)
def reportdiff(expected
, output
):
a
= expected
.splitlines(1)
sm
= difflib
.SequenceMatcher(a
=a
, b
=b
)
tuples
= sm
.get_opcodes()
# x0:x1 are 0-based slice indices; convert to 1-based line indices.
return "lines %d-%d" % (x0
, x1
)
for op
, a0
, a1
, b0
, b1
in tuples
:
print "***", pair(a0
, a1
), "of expected output missing:"
print "*** mismatch between", pair(a0
, a1
), "of expected", \
"output and", pair(b0
, b1
), "of actual output:"
for line
in difflib
.ndiff(a
[a0
:a1
], b
[b0
:b1
]):
print "***", pair(b0
, b1
), "of actual output doesn't appear", \
"in expected output after line", str(a1
)+":"
print "get_opcodes() returned bad tuple?!?!", (op
, a0
, a1
, b0
, b1
)
if __name__
== '__main__':
testdir
= os
.path
.dirname(file) or os
.curdir
if name
.endswith(os
.extsep
+ "py"):
return "%d %s" % (n
, word
)
return "%d %ss" % (n
, word
)
def printlist(x
, width
=70, indent
=4):
"""Print the elements of iterable x to stdout.
Optional arg width (default 70) is the maximum line length.
Optional arg indent (default 4) is the number of blanks with which to
from textwrap
import fill
print fill(' '.join(map(str, x
)), width
,
initial_indent
=blanks
, subsequent_indent
=blanks
)
# Map sys.platform to a string containing the basenames of tests
# expected to be skipped on that platform.
# The _ExpectedSkips constructor adds this to the set of expected
# skips if not os.path.supports_unicode_filenames.
# Whether a skip is expected here depends on whether a large test
# input file has been downloaded. test_normalization.skip_expected
# Controlled by test_socket_ssl.skip_expected. Requires the network
# resource, and a socket module with ssl support.
# Controlled by test_timeout.skip_expected. Requires the network
# resource and a socket module.
# Whether a skip is expected here depends on whether a large test
# input file has been downloaded. test_codecmaps_*.skip_expected
_expectations
['freebsd5'] = _expectations
['freebsd4']
_expectations
['freebsd6'] = _expectations
['freebsd4']
from test
import test_normalization
from test
import test_socket_ssl
from test
import test_timeout
from test
import test_codecmaps_cn
, test_codecmaps_jp
from test
import test_codecmaps_kr
, test_codecmaps_tw
from test
import test_codecmaps_hk
if sys
.platform
in _expectations
:
s
= _expectations
[sys
.platform
]
self
.expected
= set(s
.split())
if not os
.path
.supports_unicode_filenames
:
self
.expected
.add('test_pep277')
if test_normalization
.skip_expected
:
self
.expected
.add('test_normalization')
if test_socket_ssl
.skip_expected
:
self
.expected
.add('test_socket_ssl')
if test_timeout
.skip_expected
:
self
.expected
.add('test_timeout')
for cc
in ('cn', 'jp', 'kr', 'tw', 'hk'):
if eval('test_codecmaps_' + cc
).skip_expected
:
self
.expected
.add('test_codecmaps_' + cc
)
if sys
.maxint
== 9223372036854775807L:
self
.expected
.add('test_rgbimg')
self
.expected
.add('test_imageop')
if not sys
.platform
in ("mac", "darwin"):
MAC_ONLY
= ["test_macostools", "test_macfs", "test_aepack",
"test_plistlib", "test_scriptpackages"]
if sys
.platform
!= "win32":
WIN_ONLY
= ["test_unicode_file", "test_winreg",
"Return true iff _ExpectedSkips knows about the current platform."
"""Return set of test names we expect to skip on current platform.
self.isvalid() must be true.
if __name__
== '__main__':
# Remove regrtest.py's own directory from the module search path. This
# prevents relative imports from working, and relative imports will screw
# up the testing framework. E.g. if both test.test_support and
# test_support are imported, they will not contain the same globals, and
# much of the testing framework relies on the globals in the
# test.test_support module.
mydir
= os
.path
.abspath(os
.path
.normpath(os
.path
.dirname(sys
.argv
[0])))
i
= pathlen
= len(sys
.path
)
if os
.path
.abspath(os
.path
.normpath(sys
.path
[i
])) == mydir
:
if len(sys
.path
) == pathlen
:
print 'Could not find %r in sys.path to remove it' % mydir