def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
self.json_data["execution_time"] = format(timeTaken, "0.2f")
total_score = 0
for test in self.json_data["tests"]:
total_score += test["score"]
self.json_data["score"] = total_score
json.dump(self.json_data, self.stream, indent=4)
self.stream.write('\n')
return result
def run(self, test):
""" Copied and modified from TextTestRunner
Run the given test case or test suite."""
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
start_time = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stop_time = time.time()
timeTaken = stop_time - start_time
result.printErrors()
if hasattr(result, 'separator2'):
self.stream.writeln(result.separator1)
run = result.testsRun
self.stream.writeln(' \033[1mRan %d test%s in %.3fs' %
(run, run != 1 and 's' or '', timeTaken))
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures, # pylint: disable=bad-builtin
result.unexpectedSuccesses,
result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
if not result.wasSuccessful():
self.stream.write(' \033[1;31mFAILED\033[00m')
failed = len(result.failures)
errored = len(result.errors)
if failed:
infos.append('failures = \033[00;31m%d\033[00m' % failed)
if errored:
infos.append('errors = \033[00;31m%d\033[00m' % errored)
else:
self.stream.write(' \033[1;32mOK\033[00m')
if skipped:
infos.append('skipped = \033[00;33m%d\033[00m' % skipped)
if expectedFails:
infos.append('expected failures=%d' % expectedFails)
if unexpectedSuccesses:
infos.append('unexpected successes=%d' % unexpectedSuccesses)
if infos:
self.stream.writeln(' (%s)' % (', '.join(infos),))
self.stream.write('\n')
return result
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
self.json_data["execution_time"] = format(timeTaken, "0.2f")
total_score = 0
for test in self.json_data["tests"]:
total_score += test["score"]
self.json_data["score"] = total_score
json.dump(self.json_data, self.stream, indent=4)
self.stream.write('\n')
return result
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
result.printErrors()
if hasattr(result, 'separator2'):
self.stream.writeln(result.separator2)
run = result.testsRun
self.stream.writeln("Ran %d test%s in %.3fs" %
(run, run != 1 and "s" or "", timeTaken))
self.stream.writeln()
return result
def run(self, test):
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
with warnings.catch_warnings():
if getattr(self, "warnings", None):
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.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']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
result.total_tests = test.countTestCases()
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
return result
def run(self, test):
""" Run the given test case or test suite. Copied from unittest to replace the startTestRun
callback"""
result = self._makeResult()
result.failfast = self.failfast
result.buffer = self.buffer
registerResult(result)
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun(test.countTestCases())
try:
self._injectDevice(test)
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun(time.time() - startTime)
else:
result.printErrors()
stopTime = time.time()
timeTaken = stopTime - startTime
if hasattr(result, 'separator2'):
self.stream.writeln(result.separator2)
run = result.testsRun
self.stream.writeln('Ran %d test%s in %.3fs' %
(run, run != 1 and 's' or '', timeTaken))
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses, result.skipped))
expectedFails, unexpectedSuccesses, skipped = results
except AttributeError:
pass
infos = []
if not result.wasSuccessful():
self.stream.write('FAILED')
failed, errored = map(len, (result.failures, result.errors))
if failed:
infos.append('failures=%d' % failed)
if errored:
infos.append('errors=%d' % errored)
else:
self.stream.write('OK')
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:
self.stream.writeln(' (%s)' % (', '.join(infos), ))
else:
self.stream.write('\n')
return result
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
result.printErrors()
if hasattr(result, 'separator2'):
self.stream.writeln(result.separator2)
run = result.testsRun
self.stream.writeln("Ran %d test%s in %.3fs" %
(run, run != 1 and "s" or "", timeTaken))
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses,
result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
if not result.wasSuccessful():
self.stream.write("FAILED")
failed, errored = map(len, (result.failures, result.errors))
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
else:
self.stream.write("OK")
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:
self.stream.writeln(" (%s)" % (", ".join(infos),))
else:
self.stream.write("\n")
return result
def __init_test_result_config(self, test: TestSuite):
registerResult(self.result)
self.result.failfast = self.failfast
self.result.buffer = self.buffer
self.result.tb_locals = self.tb_locals
self.result.fail_fast = self.failfast
if hasattr(test, 'properties'):
# junit test suite properties
self.result.properties = test.properties
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
run = result.testsRun
self.log.info("Ran %d test%s in %.3fs",
run, run != 1 and "s" or "", timeTaken)
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses,
result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
summary = StringIO()
lvl = logging.INFO
if not result.wasSuccessful():
summary.write("FAILED")
lvl = logging.ERROR
failed, errored = map(len, (result.failures, result.errors))
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
else:
summary.write("OK")
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:
summary.write(" (%s)" % (", ".join(infos),))
self.log.log(lvl, summary.getvalue())
return result
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
run = result.testsRun
self.log.info("Ran %d test%s in %.3fs", run, run != 1 and "s" or "",
timeTaken)
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses, result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
summary = StringIO()
lvl = logging.INFO
if not result.wasSuccessful():
summary.write("FAILED")
lvl = logging.ERROR
failed, errored = map(len, (result.failures, result.errors))
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
else:
summary.write("OK")
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:
summary.write(" (%s)" % (", ".join(infos), ))
self.log.log(lvl, summary.getvalue())
return result
def run(self, suite):
"Run the given test case or test suite."
result = GreenTestResult(
self.stream, self.descriptions, self.verbosity, html=self.html,
termcolor=self.termcolor)
registerResult(result)
with warnings.catch_warnings():
if self.warnings:
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.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']:
warnings.filterwarnings('module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
result.startTestRun()
if self.subprocesses == 1:
suite.run(result)
else:
tests = toProtoTestList(suite)
pool = LoggingDaemonlessPool(processes=self.subprocesses)
if tests:
async_responses = []
for index, test in enumerate(tests):
if self.run_coverage:
coverage_number = index + 1
else:
coverage_number = None
async_responses.append(pool.apply_async(
poolRunner,
(test.dotted_name, coverage_number, self.omit)))
pool.close()
for test, async_response in zip(tests, async_responses):
# Prints out the white 'processing...' version of the output
result.startTest(test)
# This blocks until the worker who is processing this
# particular test actually finishes
result.addProtoTestResult(async_response.get())
pool.terminate()
pool.join()
result.stopTestRun()
return result
def _before_run(self):
# Keep the same as lines 145-162 in unittest.TextTextRunner.run
result = self.resultclass(self.stream, self.descriptions, self.verbosity)
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
with warnings.catch_warnings():
warn = getattr(self, 'warnings', None)
if warn:
warnings.simplefilter(warn)
if warn in ['default', 'always']:
warnings.filterwarnings('module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
return result
def run(self, test):
"""
Run the given test case or test suite.
"""
result = self.makeResult()
registerResult(result)
result.failfast = self.failfast
result.startTestRun()
try:
test(result)
finally:
result.stopTestRun()
result.report()
return result
def _before_run(self):
# Keep the same as lines 145-162 in unittest.TextTextRunner.run
result = self.make_result()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
with warnings.catch_warnings():
warn = getattr(self, 'warnings', None)
if warn:
warnings.simplefilter(warn)
if warn in ['default', 'always']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
return result
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
return result
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
return result
def __call__(self, test):
# Executed in child process
kwargs = self.runner_args
# Force recording of output in a buffer (it will be printed out
# by the parent).
kwargs['stream'] = StringIO()
runner = self.runner_cls(**kwargs)
result = runner._makeResult()
# Avoid child tracebacks when Ctrl-C is pressed.
signals.installHandler()
signals.registerResult(result)
result.failfast = runner.failfast
result.buffer = runner.buffer
with self.cleanup_object(test):
test(result)
# HACK as cStringIO.StringIO isn't picklable in 2.x
result.stream = _FakeStringIO(result.stream.getvalue())
return _MinimalResult(result, test.id())
def __call__(self, test):
# Executed in child process
kwargs = self.runner_args
# Force recording of output in a buffer (it will be printed out
# by the parent).
kwargs["stream"] = StringIO()
runner = self.runner_cls(**kwargs)
result = runner._makeResult()
# Avoid child tracebacks when Ctrl-C is pressed.
signals.installHandler()
signals.registerResult(result)
result.failfast = runner.failfast
result.buffer = runner.buffer
with self.cleanup_object(test):
test(result)
# HACK as cStringIO.StringIO isn't picklable in 2.x
result.stream = _FakeStringIO(result.stream.getvalue())
return _MinimalResult(result)
def run(self, test):
"""Run the given test case or test suite."""
# This is initializing the given result class. This is how we will treat the result
result = self._makeSlickResult()
# These are set to keep compatibility with the unit test framework
registerResult(result)
result.failfast = self.failfast
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
if test:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
return result
def run(self, suite, testName=None):
"Run the given test case or test suite."
errorsOrFailures = 0
for test in suite:
if testName == None or test._testMethodName == testName:
result = ObjectTestResult()
registerResult(result)
result.failfast = self.failfast
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
errorsOrFailures += len(result.errors) + len(
result.failures)
self.testResults.append(result.getTestResult())
if testName != None:
self.testResults = self.testResults[0]
return errorsOrFailures
def run(suite, stream, args, testing=False):
"""
Run the given test case or test suite with the specified arguments.
Any args.stream passed in will be wrapped in a GreenStream
"""
if not issubclass(GreenStream, type(stream)):
stream = GreenStream(stream, disable_windows=args.disable_windows)
result = GreenTestResult(args, stream)
# Note: Catching SIGINT isn't supported by Python on windows (python
# "WONTFIX" issue 18040)
installHandler()
registerResult(result)
with warnings.catch_warnings():
if args.warnings: # pragma: no cover
# if args.warnings is set, use it to filter all the warnings
warnings.simplefilter(args.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 args.warnings is None.
if args.warnings in ['default', 'always']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
result.startTestRun()
pool = LoggingDaemonlessPool(
processes=args.processes or None,
initializer=InitializerOrFinalizer(args.initializer),
finalizer=InitializerOrFinalizer(args.finalizer))
manager = multiprocessing.Manager()
targets = [(target, manager.Queue())
for target in toParallelTargets(suite, args.targets)]
if targets:
for index, (target, queue) in enumerate(targets):
if args.run_coverage:
coverage_number = index + 1
else:
coverage_number = None
debug("Sending {} to runner {}".format(target, poolRunner))
pool.apply_async(
poolRunner,
(target, queue, coverage_number, args.omit_patterns))
pool.close()
for target, queue in targets:
abort = False
while True:
msg = queue.get()
# Sentinel value, we're done
if not msg:
break
else:
# Result guaranteed after this message, we're
# currently waiting on this test, so print out
# the white 'processing...' version of the output
result.startTest(msg)
proto_test_result = queue.get()
result.addProtoTestResult(proto_test_result)
if result.shouldStop:
abort = True
break
if abort:
break
pool.close()
pool.join()
result.stopTestRun()
removeResult(result)
return result
def run(suite, stream, args, testing=False):
"""
Run the given test case or test suite with the specified arguments.
Any args.stream passed in will be wrapped in a GreenStream
"""
if not issubclass(GreenStream, type(stream)):
stream = GreenStream(stream)
result = GreenTestResult(args, stream)
# Note: Catching SIGINT isn't supported by Python on windows (python
# "WONTFIX" issue 18040)
installHandler()
registerResult(result)
with warnings.catch_warnings():
if args.warnings: # pragma: no cover
# if args.warnings is set, use it to filter all the warnings
warnings.simplefilter(args.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 args.warnings is None.
if args.warnings in ['default', 'always']:
warnings.filterwarnings('module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
result.startTestRun()
pool = LoggingDaemonlessPool(processes=args.processes or None,
initializer=InitializerOrFinalizer(args.initializer),
finalizer=InitializerOrFinalizer(args.finalizer))
manager = multiprocessing.Manager()
targets = [(target, manager.Queue()) for target in toParallelTargets(suite, args.targets)]
if targets:
for index, (target, queue) in enumerate(targets):
if args.run_coverage:
coverage_number = index + 1
else:
coverage_number = None
pool.apply_async(
poolRunner,
(target, queue, coverage_number, args.omit_patterns))
pool.close()
for target, queue in targets:
abort = False
while True:
msg = queue.get()
# Sentinel value, we're done
if not msg:
break
else:
# Result guarunteed after this message, we're
# currently waiting on this test, so print out
# the white 'processing...' version of the output
result.startTest(msg)
proto_test_result = queue.get()
result.addProtoTestResult(proto_test_result)
if result.shouldStop:
abort = True
break
if abort:
break
pool.close()
pool.join()
result.stopTestRun()
removeResult(result)
return result
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
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
warnings.simplefilter(self.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']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message=r'Please use assert\w+ instead.')
startTime = datetime.datetime.now()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = datetime.datetime.now()
result.timeTaken = result.getTimeTaken(stopTime, startTime)
#add by yang
result.startTime = str(startTime)[:-7]
result.stopTime = str(stopTime)[:-7]
# result.printErrors() annotate by yang
# if hasattr(result, 'separator2'):
# self.stream.writeln(result.separator2)
# run = result.testsRun
# self.stream.writeln("Ran %d test%s in %.3fs" %
# (run, run != 1 and "s" or "", timeTaken))
# self.stream.writeln()
# expectedFails = unexpectedSuccesses = skipped = 0
# try:
# results = map(len, (result.expectedFailures,
# result.unexpectedSuccesses,
# result.skipped))
# except AttributeError:
# pass
# else:
# expectedFails, unexpectedSuccesses, skipped = results
#
# infos = []
# if not result.wasSuccessful():
# self.stream.write("FAILED")
# failed, errored = len(result.failures), len(result.errors)
# if failed:
# infos.append("failures=%d" % failed)
# if errored:
# infos.append("errors=%d" % errored)
# else:
# self.stream.write("OK")
# 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:
# self.stream.writeln(" (%s)" % (", ".join(infos),))
# else:
# self.stream.write("\n")
return result
def run(suite, stream, args, testing=False):
"""
Run the given test case or test suite with the specified arguments.
Any args.stream passed in will be wrapped in a GreenStream
"""
# check if the kubefwd is running, then stop the run
if check_kubefwd_running():
return GreenTestResult(args, stream)
if not issubclass(GreenStream, type(stream)):
stream = GreenStream(
stream,
disable_windows=args.disable_windows,
disable_unidecode=args.disable_unidecode,
)
result = GreenTestResult(args, stream)
# Note: Catching SIGINT isn't supported by Python on windows (python
# "WONTFIX" issue 18040)
installHandler()
registerResult(result)
with warnings.catch_warnings():
if args.warnings: # pragma: no cover
# if args.warnings is set, use it to filter all the warnings
warnings.simplefilter(args.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 args.warnings is None.
if args.warnings in ["default", "always"]:
warnings.filterwarnings(
"module",
category=DeprecationWarning,
message="Please use assert\w+ instead.",
)
result.startTestRun()
# The call to toParallelTargets needs to happen before pool stuff so we can crash if there
# are, for example, syntax errors in the code to be loaded.
parallel_targets = toParallelTargets(suite, args.targets)
pool = LoggingDaemonlessPool(
processes=args.processes or None,
initializer=InitializerOrFinalizer(args.initializer),
finalizer=InitializerOrFinalizer(args.finalizer),
)
manager = multiprocessing.Manager()
targets = [(target, manager.Queue()) for target in parallel_targets]
if targets:
for index, (target, queue) in enumerate(targets):
if args.run_coverage:
coverage_number = index + 1
else:
coverage_number = None
debug("Sending {} to poolRunner {}".format(target, poolRunner))
pool.apply_async(
poolRunner,
(
target,
queue,
coverage_number,
args.omit_patterns,
args.cov_config_file,
),
)
pool.close()
for target, queue in targets:
abort = False
while True:
msg = queue.get()
# Sentinel value, we're done
if not msg:
debug("runner.run(): received sentinal, breaking.", 3)
break
else:
debug("runner.run(): start test: {}".format(msg))
# Result guaranteed after this message, we're
# currently waiting on this test, so print out
# the white 'processing...' version of the output
result.startTest(msg)
proto_test_result = queue.get()
debug(
"runner.run(): received proto test result: {}".
format(str(proto_test_result)),
3,
)
result.addProtoTestResult(proto_test_result)
if result.shouldStop:
debug("runner.run(): shouldStop encountered, breaking",
3)
abort = True
break
if abort:
break
pool.close()
pool.join()
result.stopTestRun()
removeResult(result)
return result
def run(self, test):
"""Run the given test case or test suite."""
self.resultclass.number_of_tests = test.countTestCases()
if self.verbosity >= 2:
self.stream.writeln(colored('\nTesting:\n', attrs=['bold']))
else:
self.stream.writeln('Testing...')
self._check_suites(test)
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
with warnings.catch_warnings():
if self.warnings:
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.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']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
result.printErrors()
run = result.testsRun
details = {
'success': result.wasSuccessful(),
'failures': len(result.failures) + len(result.unexpectedSuccesses),
'errors': len(result.errors),
'skipped': len(result.skipped),
'time': round(timeTaken, 3),
'sum': run,
}
details['successes'] = run - (details['failures'] + details['errors'])
result.printSummary(details)
return result
def run(self, test: object) -> TestResult:
""" @abstract Run the test suite or case and display the report
@params test [TestSuite|TestCase] Test suite or case object to run
@returns [TestResult] Outputs formatted text report and returns
a TestResult object on success.
"""
result = self._makeResult()
registerResult(result)
result.timing = self.timing
result.failfast = self.failfast
result.buffer = self.buffer
result.tb_locals = self.tb_locals
timetaken = 0
with warnings.catch_warnings():
if self.warnings:
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.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']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message=r'Please use assert\w+ instead.')
#overall testruntime
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
# We need to start building the report to display
_reportOrder = result.tally.keys()
if self.mode == "full-report":
_summary_table = TextTable(self._summary_props)
_total_count = _total_success = _total_fail = _total_err = 0
_total_skip = _total_unexpS = _total_expectF = 0
for _clsName in _reportOrder:
# "Count", "Pass", "Fail", "Error", "Skip", "UnexpS", "ExpectF"],
_test_count = sum(result.tally[_clsName].values())
_summary_table.appendRow([
_clsName,
str(_test_count), *result.getClassTally(_clsName)
])
_resultTotals = result.getResultTally()
_stats = ""
if self.mode == "full-report":
_summary_table.appendRow(["Totals", *_resultTotals])
_reports = [("Summary", _summary_table)]
for _cls in _reportOrder:
_clsSet = result.results[_cls]
if self.mode == "full-report":
_report = TextTable(self._test_props)
_single = len(_clsSet) == 1
for _name, _test, _status, _output in _clsSet:
if self.mode == "full-report":
if self.timing:
_execTimes = result.execTimes[_test.id()]
_runTime = round(
_execTimes["stop"] - _execTimes["start"], 3)
_statStr = "({}s) {}".format(_runTime,
result.STATUS[_status])
else:
_statStr = "{}".format(result.STATUS[_status])
_report.appendRow(cells=[_name, _output, _statStr],
single=_single)
else:
_stats += _status
if self.mode == "full-report":
_reports.append((_cls, _report))
if self.mode == "full-report":
for _heading, _report in _reports:
print(_heading)
_report.draw()
if self.timing:
print("runtime: {}s".format(round(timeTaken, 3)))
else:
_stats += " " if len(_stats) > 0 else ""
# Simple Summary
simplereport = "{}pass: {}, failed: {}, errors: {}, runtime: {}s"
print(
simplereport.format(_stats, _resultTotals[1], _resultTotals[3],
_resultTotals[2], round(timeTaken, 3)))
return result
def run(self, test, logdir=None):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
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
warnings.simplefilter(self.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']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message=r'Please use assert\w+ instead.')
startTime = time.perf_counter()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
all_case_name = [ts.id() for ts in test]
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.perf_counter()
timeTaken = stopTime - startTime
_, cfg_data = utils_lib.get_cfg()
if logdir is None:
logdir = cfg_data['results_dir']
sum_html = logdir + '/sum.html'
sum_txt = logdir + '/sum.log'
if os.path.exists(sum_txt):
os.unlink(sum_txt)
html_sum = HTMLTemp(sum_html)
html_sum.run_time = timeTaken
all_case_name.sort()
id = 0
for case in all_case_name:
id += 1
is_pass = True
os.chdir(logdir)
debug_log = "debug/" + case + '.debug'
for ts, err in result.failures:
if case == ts.id():
is_pass = False
html_sum.result.case_fail += 1
html_sum.result.table_rows.append(
(id, case, 'FAIL', err, debug_log))
with open(debug_log, 'a+') as fh:
fh.write(err)
fh.write('{} - FAIL'.format(case))
with open(sum_txt, 'a+') as fh:
fh.write('case: {} - FAIL\n'.format(case))
fh.write('info: {}\n'.format(err))
break
if not is_pass:
continue
for ts, err in result.errors:
if case == ts.id():
is_pass = False
html_sum.result.case_error += 1
html_sum.result.table_rows.append(
(id, case, 'ERROR', err, debug_log))
with open(debug_log, 'a+') as fh:
fh.write(err)
fh.write('{} - ERROR'.format(case))
with open(sum_txt, 'a+') as fh:
fh.write('case: {} - ERROR\n'.format(case))
fh.write('info: {}\n'.format(err))
break
def run(self, test, test_result=None):
"Run the given test case or test suite."
# Monkey patch on unittest class to add not implemented errors into run
if test_result is None:
test_result = self._makeResult()
registerResult(test_result)
test_result.failfast = self.failfast
test_result.buffer = self.buffer
startTime = time.time()
startTestRun = getattr(test_result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(test_result)
finally:
stopTestRun = getattr(test_result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
test_result.printErrors()
if hasattr(test_result, 'separator2'):
self.stream.writeln(test_result.separator2)
run = test_result.testsRun
self.stream.writeln("Ran %d test%s in %.3fs" %
(run, run != 1 and "s" or "", timeTaken))
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(
len,
(test_result.expectedFailures, test_result.unexpectedSuccesses,
test_result.skipped, test_result.not_implemented))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped, not_implemented = results
infos = []
if not test_result.wasSuccessful():
self.stream.write("FAILED")
failed, errored = map(len,
(test_result.failures, test_result.errors))
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
else:
self.stream.write("OK")
if skipped:
infos.append("skipped=%d" % skipped)
if expectedFails:
infos.append("expected failures=%d" % expectedFails)
if unexpectedSuccesses:
infos.append("unexpected successes=%d" % unexpectedSuccesses)
if not_implemented:
infos.append("not implemented=%d" % not_implemented)
if infos:
self.stream.writeln(" (%s)" % (", ".join(infos), ))
else:
self.stream.write("\n")
return test_result
def run(self, test):
"Run the given test case or test suite."
result = MPITestResult(
self.comm, self.stream, self.descriptions, self.verbosity
)
registerResult(result)
with warnings.catch_warnings():
if self.warnings:
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.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"]:
warnings.filterwarnings(
"module",
category=DeprecationWarning,
message=r"Please use assert\w+ instead.",
)
startTime = time.time()
startTestRun = getattr(result, "startTestRun", None)
if startTestRun is not None:
startTestRun()
try:
test(result=result)
finally:
stopTestRun = getattr(result, "stopTestRun", None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
self.stream.flush()
if self.comm is None:
self.stream.write("\n")
self.stream.flush()
else:
self.comm.barrier()
if self.comm.rank == 0:
self.stream.write("\n")
self.stream.flush()
timeTaken = stopTime - startTime
result.printErrors()
if (self.comm is None) or (self.comm.rank == 0):
if hasattr(result, "separator2"):
self.stream.writeln(result.separator2)
run = result.testsRun
if (self.comm is None) or (self.comm.rank == 0):
self.stream.writeln(
"Ran %d test%s in %.3fs" % (run, run != 1 and "s" or "", timeTaken)
)
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(
len,
(result.expectedFailures, result.unexpectedSuccesses, result.skipped),
)
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
psize = 1
prank = 0
if self.comm is not None:
psize = self.comm.size
prank = self.comm.rank
for p in range(psize):
if p == prank:
infos = []
if not result.wasSuccessful():
if self.comm is None:
self.stream.write("FAILED")
else:
self.stream.write("[{}] FAILED".format(self.comm.rank))
failed, errored = len(result.failures), len(result.errors)
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
else:
if self.comm is None:
self.stream.write("OK")
else:
self.stream.write("[{}] OK".format(self.comm.rank))
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:
self.stream.writeln(" ({})".format(", ".join(infos)))
else:
self.stream.write("\n")
self.stream.flush()
if self.comm is not None:
self.comm.barrier()
# if not result.allSuccessful():
# self.comm.Abort(1)
return result
def run(self, test, logdir=None):
"Run the given test case or test suite."
result = self._makeResult()
test_result = Result()
registerResult(result)
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
warnings.simplefilter(self.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']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message=r'Please use assert\w+ instead.')
startTime = time.perf_counter()
id = 0
all_case_name = [ts.id() for ts in test]
for ts in test:
logdir = ts.params['results_dir']
if not os.path.exists(logdir):
os.mkdir(logdir)
results_dir = logdir + '/results'
if not os.path.exists(results_dir):
os.mkdir(results_dir)
sum_txt = results_dir + '/sum.log'
case_status = None
case_reason = None
id += 1
case_startTime = time.perf_counter()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
ts(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
ts.duration = timeTaken = round(
time.perf_counter() - case_startTime, 3)
test_class_name = ts.__class__.__name__
case_dir = '.'.join([test_class_name, ts.id()])
debug_dir = logdir + "/attachments/" + case_dir
if not os.path.exists(debug_dir):
os.mkdir(debug_dir)
debug_log = "../attachments/" + case_dir + '/' + ts.id(
) + '.debug'
with pushd(results_dir):
mapped_result = {
'FAIL': result.failures,
'ERROR': result.errors,
'SKIP': result.skipped
}
for status in mapped_result.keys():
for ts_finished, reason in mapped_result[status]:
if ts_finished == ts:
if status == 'FAIL':
test_result.case_fail += 1
if status == 'ERROR':
test_result.case_error += 1
if status == 'SKIP':
test_result.case_skip += 1
case_status = status
case_reason = reason
with open(debug_log, 'a+') as fh:
fh.write(reason)
fh.write('{} - {}'.format(ts.id(), status))
break
if not case_status:
test_result.case_pass += 1
with open(debug_log, 'a+') as fh:
fh.write('{} - PASS'.format(ts.id()))
case_status = 'PASS'
case_reason = ''
test_result.table_rows.append([
id,
ts.id(), case_status, case_reason, ts.duration, debug_log,
test_class_name
])
with open(sum_txt, 'a+') as fh:
fh.write('case: {} - {}\n'.format(ts.id(), case_status))
if case_reason:
fh.write('info: {}\n'.format(case_reason))
stopTime = time.perf_counter()
timeTaken = round(stopTime - startTime, 3)
test_result.run_time = timeTaken
all_case_name.sort()
id = 0
for case in all_case_name:
id += 1
is_pass = True
# os.chdir(logdir)
debug_log = "../attachments/" + case + '.debug'
if hasattr(result, 'separator2'):
self.stream.writeln(result.separator2)
test_result.compute_totals()
node_info_file = "{}/attachments/node_info".format(logdir)
if os.path.exists(node_info_file):
with open(node_info_file) as fh:
test_result.node_info = fh.read()
results_dir = logdir + '/results'
if not os.path.exists(results_dir):
os.mkdir(results_dir)
sum_html = os.path.join(results_dir, "sum.html")
generated_report(sum_html, "sum.html", test_result)
sum_junit = os.path.join(results_dir, "sum.xml")
generated_report(sum_junit, "sum.xml", test_result)
self.stream.writeln("{} generated".format(os.path.realpath(sum_txt)))
#result.printErrors()
if hasattr(result, 'separator2'):
self.stream.writeln(result.separator2)
run = result.testsRun
self.stream.writeln("Ran %d test%s in %.3fs" %
(run, run != 1 and "s" or "", timeTaken))
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses, result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
if not result.wasSuccessful():
self.stream.write("FAILED")
failed, errored = len(result.failures), len(result.errors)
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
else:
self.stream.write("OK")
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:
self.stream.writeln(" (%s)" % (", ".join(infos), ))
else:
self.stream.write("\n")
return result
def run(self, test):
""" Copied and modified from TextTestRunner
Run the given test case or test suite."""
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
start_time = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stop_time = time.time()
timeTaken = stop_time - start_time
result.printErrors()
if hasattr(result, 'separator2'):
self.stream.writeln(result.separator1)
run = result.testsRun
self.stream.writeln(' \033[1mRan %d test%s in %.3fs' %
(run, run != 1 and 's' or '', timeTaken))
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(
len,
(
result.expectedFailures, # pylint: disable=bad-builtin
result.unexpectedSuccesses,
result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
if not result.wasSuccessful():
self.stream.write(' \033[1;31mFAILED\033[00m')
failed = len(result.failures)
errored = len(result.errors)
if failed:
infos.append('failures = \033[00;31m%d\033[00m' % failed)
if errored:
infos.append('errors = \033[00;31m%d\033[00m' % errored)
else:
self.stream.write(' \033[1;32mOK\033[00m')
if skipped:
infos.append('skipped = \033[00;33m%d\033[00m' % skipped)
if expectedFails:
infos.append('expected failures=%d' % expectedFails)
if unexpectedSuccesses:
infos.append('unexpected successes=%d' % unexpectedSuccesses)
if infos:
self.stream.writeln(' (%s)' % (', '.join(infos), ))
self.stream.write('\n')
return result
def run(self, test):
"""Run the given test case or test suite."""
results = self._make_result()
registerResult(results)
results.failfast = self.failfast
results.buffer = self.buffer
results.tb_locals = self.tb_locals
with warnings.catch_warnings():
if self.warnings:
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.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']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
start_time = time.time()
start_test_run = getattr(results, 'start_test_run', None)
if start_test_run is not None:
start_test_run()
try:
test(results)
finally:
stop_test_run = getattr(results, 'stopTestRun', None)
if stop_test_run is not None:
stop_test_run()
stop_time = time.time()
time_taken = stop_time - start_time
results.printErrors()
if hasattr(results, 'separator2'):
self.stream.writeln(results.separator2)
run = results.testsRun
self.stream.writeln("Ran %d test%s in %.3fs" %
(run, run != 1 and "s" or "", time_taken))
self.stream.writeln()
expected_fails = unexpected_successes = skipped = 0
try:
results_text = map(len,
(results.expectedFailures,
results.unexpectedSuccesses, results.skipped))
except AttributeError:
pass
else:
expected_fails, unexpected_successes, skipped = results_text
results.set_test_time(
time.strftime("%b %d %Y %H:%M:%S", time.gmtime(start_time)),
format(time_taken, ".2f"))
if self.report_path is not None:
results.dump_results_into_json(self.report_path)
info_results = []
if not results.wasSuccessful():
self.stream.write("FAILED")
failed, error = len(results.failures), len(results.errors)
if failed:
info_results.append("failures=%d" % failed)
if error:
info_results.append("errors=%d" % error)
else:
self.stream.write("OK")
if skipped:
info_results.append("skipped=%d" % skipped)
if expected_fails:
info_results.append("expected failures=%d" % expected_fails)
if unexpected_successes:
info_results.append("unexpected successes=%d" %
unexpected_successes)
if info_results:
self.stream.writeln(" (%s)" % (", ".join(info_results), ))
else:
self.stream.write("\n")
return results
def run(self, test):
"Run the given test case or test suite."
# convert test classes to Tango Test Suite compliant
def convertToTango(test):
try:
iter(test)
except TypeError:
test.__class__.__bases__ = (TangoTestCase, )
else:
test.__class__ = TangoTestSuite
for t in test:
convertToTango(t)
convertToTango(test)
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
result.printErrors()
if hasattr(result, 'separator2'):
self.stream.writeln(result.separator2)
run = result.testsRun
self.stream.writeln("Ran %d test%s in %.3fs" %
(run, run != 1 and "s" or "", timeTaken))
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses, result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
if not result.wasSuccessful():
self.stream.write("FAILED")
failed, errored = map(len, (result.failures, result.errors))
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
else:
self.stream.write("OK")
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:
self.stream.writeln(" (%s)" % (", ".join(infos), ))
else:
self.stream.write("\n")
return result
def run(self, test):
"""Run the given test case or test suite.
:param test: test suite.
:type test: unittest.TestSuite
:return: test result.
:rtype: TextTestResult
"""
test_result = self._make_result()
registerResult(test_result)
test_result.failfast = self.failfast
test_result.buffer = self.buffer
test_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
warnings.simplefilter(self.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']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
start_time = time.time()
start_test_run = getattr(test_result, 'startTestRun', None)
if start_test_run is not None:
start_test_run()
try:
test(test_result)
finally:
stop_test_run = getattr(test_result, 'stopTestRun', None)
if stop_test_run is not None:
stop_test_run()
stop_time = time.time()
time_taken = stop_time - start_time
test_result.printErrors()
# if hasattr(result, 'separator2'):
# self.stream.writeln(result.separator2)
run = test_result.testsRun
logline = "Ran %d test%s in %.3fs" % (run, run != 1 and "s"
or "", time_taken)
easyb.log.inform("RUNNER", logline)
expected_fails = unexpected_successes = skipped = 0
try:
results = map(
len, (test_result.expectedFailures,
test_result.unexpectedSuccesses, test_result.skipped))
except AttributeError:
pass
else:
expected_fails, unexpected_successes, skipped = results
infos = []
if not test_result.wasSuccessful():
failed, errored = len(test_result.failures), len(
test_result.errors)
if failed:
easyb.log.warn("FAILURES", str(failed))
if errored:
easyb.log.warn("ERRORS", str(errored))
else:
easyb.log.inform("RUNNER", "OK")
if skipped:
infos.append("skipped=%d" % skipped)
if expected_fails:
infos.append("expected failures=%d" % expected_fails)
if unexpected_successes:
infos.append("unexpected successes=%d" % unexpected_successes)
if infos:
logline = " (%s)" % (", ".join(infos), )
easyb.log.raw(logline)
return test_result
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
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
warnings.simplefilter(self.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']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message=r'Please use assert\w+ instead.')
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
result.printErrors()
if hasattr(result, 'separator2'):
logger.info(result.separator2)
run = result.testsRun
logger.info("Ran %d test%s in %.3fs\r\n" %
(run, run != 1 and "s" or "", timeTaken))
# 记录测试运行时间
g.results['totalTime'] = str(round(timeTaken, 2)) + 's'
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses, result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
if not result.wasSuccessful():
logger.error("FAILED!" + "\r\n")
failed, errored = len(result.failures), len(result.errors)
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
else:
logger.info("SUCCESS!" + "\r\n")
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:
logger.info(" (%s)" % (", ".join(infos), ))
else:
logger.info("\n")
return result
def run(suite, stream, args):
"""
Run the given test case or test suite with the specified arguments.
Any args.stream passed in will be wrapped in a GreenStream
"""
if not issubclass(GreenStream, type(stream)):
stream = GreenStream(stream)
result = GreenTestResult(args, stream)
# Note: Catching SIGINT isn't supported by Python on windows (python
# "WONTFIX" issue 18040)
installHandler()
registerResult(result)
with warnings.catch_warnings():
if args.warnings:
# if args.warnings is set, use it to filter all the warnings
warnings.simplefilter(args.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 args.warnings is None.
if args.warnings in ['default', 'always']:
warnings.filterwarnings('module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
result.startTestRun()
tests = toProtoTestList(suite)
pool = LoggingDaemonlessPool(processes=args.subprocesses or None)
if tests:
async_responses = []
for index, test in enumerate(tests):
if args.run_coverage:
coverage_number = index + 1
else:
coverage_number = None
async_responses.append(pool.apply_async(
poolRunner,
(test.dotted_name, coverage_number, args.omit_patterns)))
pool.close()
for test, async_response in zip(tests, async_responses):
# Prints out the white 'processing...' version of the output
result.startTest(test)
# This blocks until the worker who is processing this
# particular test actually finishes
try:
result.addProtoTestResult(async_response.get())
except KeyboardInterrupt: # pragma: no cover
result.shouldStop = True
if result.shouldStop:
break
pool.terminate()
pool.join()
result.stopTestRun()
removeResult(result)
return result
def run(self, test):
'''
Run the given test case or test suite.
'''
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
with warnings.catch_warnings():
if hasattr(self, 'warnings') and self.warnings:
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.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'):
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message=r'Please use assert\w+ instead.')
# startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
# stopTime = time.time()
# timeTaken = stopTime - startTime
result.printErrors()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses, result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
if not result.wasSuccessful():
self.stream.write('FAILED')
failed, errored = len(result.failures), len(result.errors)
if failed:
infos.append(f'failures={failed}')
if errored:
infos.append(f'errors={errored}')
else:
pass
if skipped:
infos.append(f'skipped={skipped}')
if expectedFails:
infos.append(f'expected failures={expectedFails}')
if unexpectedSuccesses:
infos.append(f'unexpected successes={unexpectedSuccesses}')
if infos:
joined = ', '.join(infos)
self.stream.writeln(f' ({joined})')
else:
pass
return result
def run(self, test):
"Run the given test case or test suite."
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
with warnings.catch_warnings():
if hasattr(self, 'warnings') and self.warnings:
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.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']:
warnings.filterwarnings('module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
#startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
#stopTime = time.time()
#timeTaken = stopTime - startTime
result.printErrors()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses,
result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
infos = []
if not result.wasSuccessful():
self.stream.write("FAILED")
failed, errored = len(result.failures), len(result.errors)
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
else:
pass
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:
self.stream.writeln(" (%s)" % (", ".join(infos),))
else:
pass
return result
def run(self, test):
"""Run the given test case or test suite."""
self.resultclass.number_of_tests = test.countTestCases()
if self.verbosity >= 2:
self.stream.writeln(colored('\nTesting:\n', attrs=['bold']))
else:
self.stream.writeln('Testing...')
self._check_suites(test)
result = self._makeResult()
registerResult(result)
result.failfast = self.failfast
result.buffer = self.buffer
with warnings.catch_warnings():
if self.warnings:
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.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']:
warnings.filterwarnings(
'module',
category=DeprecationWarning,
message='Please use assert\w+ instead.')
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
result.printErrors()
run = result.testsRun
details = {
'success': result.wasSuccessful(),
'failures': len(result.failures) + len(result.unexpectedSuccesses),
'errors': len(result.errors),
'skipped': len(result.skipped),
'time': round(timeTaken, 3),
'sum': run,
}
details['successes'] = run - (details['failures'] + details['errors'])
result.printSummary(details)
return result
def run(self, test):
"Run the given test case or test suite."
result = MPITestResult(self.comm, self.stream, self.descriptions,
self.verbosity)
registerResult(result)
with warnings.catch_warnings():
if self.warnings:
# if self.warnings is set, use it to filter all the warnings
warnings.simplefilter(self.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"]:
warnings.filterwarnings("module",
category=DeprecationWarning,
message=r"Please use assert\w+ instead.")
startTime = time.time()
startTestRun = getattr(result, "startTestRun", None)
if startTestRun is not None:
startTestRun()
try:
test(result=result)
finally:
stopTestRun = getattr(result, "stopTestRun", None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
self.stream.flush()
self.comm.barrier()
if self.comm.rank == 0:
self.stream.write("\n")
self.stream.flush()
timeTaken = stopTime - startTime
result.printErrors()
if self.comm.rank == 0:
if hasattr(result, "separator2"):
self.stream.writeln(result.separator2)
run = result.testsRun
if self.comm.rank == 0:
self.stream.writeln("Ran %d test%s in %.3fs" %
(run, run != 1 and "s" or "", timeTaken))
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses,
result.skipped))
except AttributeError:
pass
else:
expectedFails, unexpectedSuccesses, skipped = results
for p in range(self.comm.size):
if p == self.comm.rank:
infos = []
if not result.wasSuccessful():
self.stream.write("[{}] FAILED".format(self.comm.rank))
failed, errored = len(result.failures), len(result.errors)
if failed:
infos.append("failures=%d" % failed)
if errored:
infos.append("errors=%d" % errored)
else:
self.stream.write("[{}] OK".format(self.comm.rank))
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:
self.stream.writeln(" ({})".format(", ".join(infos)))
else:
self.stream.write("\n")
self.stream.flush()
self.comm.barrier()
# if not result.allSuccessful():
# self.comm.Abort(1)
return result
