Skip to content
TextTestRunner of unittest.runner now uses time.perf_counter() rather
than time.time() to measure the execution time of a test: time.time()
can go backwards, whereas time.perf_counter() is monotonic.

Similar change made in libregrtest, pprint and random.
7 contributors

Users who have contributed to this file

@benjaminp @voidspace @vstinner @pitrou @bitdancer @mfoord @ezio-melotti
221 lines (191 sloc) 7.58 KB
"""Running tests"""
import sys
import time
import warnings
from . import result
from .signals import registerResult
__unittest = True
class _WritelnDecorator(object):
"""Used to decorate file-like objects with a handy 'writeln' method"""
def __init__(self,stream): = stream
def __getattr__(self, attr):
if attr in ('stream', '__getstate__'):
raise AttributeError(attr)
return getattr(,attr)
def writeln(self, arg=None):
if arg:
self.write('\n') # text-mode streams translate to \r\n if needed
class TextTestResult(result.TestResult):
"""A test result class that can print formatted text results to a stream.
Used by TextTestRunner.
separator1 = '=' * 70
separator2 = '-' * 70
def __init__(self, stream, descriptions, verbosity):
super(TextTestResult, self).__init__(stream, descriptions, verbosity) = stream
self.showAll = verbosity > 1
self.dots = verbosity == 1
self.descriptions = descriptions
def getDescription(self, test):
doc_first_line = test.shortDescription()
if self.descriptions and doc_first_line:
return '\n'.join((str(test), doc_first_line))
return str(test)
def startTest(self, test):
super(TextTestResult, self).startTest(test)
if self.showAll:" ... ")
def addSuccess(self, test):
super(TextTestResult, self).addSuccess(test)
if self.showAll:"ok")
elif self.dots:'.')
def addError(self, test, err):
super(TextTestResult, self).addError(test, err)
if self.showAll:"ERROR")
elif self.dots:'E')
def addFailure(self, test, err):
super(TextTestResult, self).addFailure(test, err)
if self.showAll:"FAIL")
elif self.dots:'F')
def addSkip(self, test, reason):
super(TextTestResult, self).addSkip(test, reason)
if self.showAll:"skipped {0!r}".format(reason))
elif self.dots:"s")
def addExpectedFailure(self, test, err):
super(TextTestResult, self).addExpectedFailure(test, err)
if self.showAll:"expected failure")
elif self.dots:"x")
def addUnexpectedSuccess(self, test):
super(TextTestResult, self).addUnexpectedSuccess(test)
if self.showAll:"unexpected success")
elif self.dots:"u")
def printErrors(self):
if self.dots or self.showAll:
self.printErrorList('ERROR', self.errors)
self.printErrorList('FAIL', self.failures)
def printErrorList(self, flavour, errors):
for test, err in errors:"%s: %s" % (flavour,self.getDescription(test)))"%s" % err)
class TextTestRunner(object):
"""A test runner class that displays results in textual form.
It prints out the names of tests as they are run, errors as they
occur, and a summary of the results at the end of the test run.
resultclass = TextTestResult
def __init__(self, stream=None, descriptions=True, verbosity=1,
failfast=False, buffer=False, resultclass=None, warnings=None,
*, tb_locals=False):
"""Construct a TextTestRunner.
Subclasses should accept **kwargs to ensure compatibility as the
interface changes.
if stream is None:
stream = sys.stderr = _WritelnDecorator(stream)
self.descriptions = descriptions
self.verbosity = verbosity
self.failfast = failfast
self.buffer = buffer
self.tb_locals = tb_locals
self.warnings = warnings
if resultclass is not None:
self.resultclass = resultclass
def _makeResult(self):
return self.resultclass(, self.descriptions, self.verbosity)
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
result.failfast = self.failfast
result.buffer = self.buffer
result.tb_locals = self.tb_locals
with warnings.catch_warnings():
if self.warnings:
# if self.warnings is set, use it to filter all the warnings
# if the filter is 'default' or 'always', special-case the
# warnings from the deprecated unittest methods to show them
# no more than once per module, because they can be fairly
# noisy. The -Wd and -Wa flags can be used to bypass this
# only when self.warnings is None.
if self.warnings in ['default', 'always']:
message=r'Please use assert\w+ instead.')
startTime = time.perf_counter()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTime = time.perf_counter()
timeTaken = stopTime - startTime
if hasattr(result, 'separator2'):
run = result.testsRun"Ran %d test%s in %.3fs" %
(run, run != 1 and "s" or "", timeTaken))
expectedFails = unexpectedSuccesses = skipped = 0
results = map(len, (result.expectedFailures,
except AttributeError:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
if not result.wasSuccessful():"FAILED")
failed, errored = len(result.failures), len(result.errors)
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
if skipped:
infos.append("skipped=%d" % skipped)
if expectedFails:
infos.append("expected failures=%d" % expectedFails)
if unexpectedSuccesses:
infos.append("unexpected successes=%d" % unexpectedSuccesses)
if infos:" (%s)" % (", ".join(infos),))
return result