mirror of https://github.com/python/cpython
1388 lines
53 KiB
Python
1388 lines
53 KiB
Python
import io
|
|
import sys
|
|
import textwrap
|
|
|
|
from test.support import warnings_helper, captured_stdout
|
|
|
|
import traceback
|
|
import unittest
|
|
from unittest.util import strclass
|
|
|
|
|
|
class MockTraceback(object):
|
|
class TracebackException:
|
|
def __init__(self, *args, **kwargs):
|
|
self.capture_locals = kwargs.get('capture_locals', False)
|
|
def format(self):
|
|
result = ['A traceback']
|
|
if self.capture_locals:
|
|
result.append('locals')
|
|
return result
|
|
|
|
def restore_traceback():
|
|
unittest.result.traceback = traceback
|
|
|
|
|
|
def bad_cleanup1():
|
|
print('do cleanup1')
|
|
raise TypeError('bad cleanup1')
|
|
|
|
|
|
def bad_cleanup2():
|
|
print('do cleanup2')
|
|
raise ValueError('bad cleanup2')
|
|
|
|
|
|
class BufferedWriter:
|
|
def __init__(self):
|
|
self.result = ''
|
|
self.buffer = ''
|
|
|
|
def write(self, arg):
|
|
self.buffer += arg
|
|
|
|
def flush(self):
|
|
self.result += self.buffer
|
|
self.buffer = ''
|
|
|
|
def getvalue(self):
|
|
return self.result
|
|
|
|
|
|
class Test_TestResult(unittest.TestCase):
|
|
# Note: there are not separate tests for TestResult.wasSuccessful(),
|
|
# TestResult.errors, TestResult.failures, TestResult.testsRun or
|
|
# TestResult.shouldStop because these only have meaning in terms of
|
|
# other TestResult methods.
|
|
#
|
|
# Accordingly, tests for the aforenamed attributes are incorporated
|
|
# in with the tests for the defining methods.
|
|
################################################################
|
|
|
|
def test_init(self):
|
|
result = unittest.TestResult()
|
|
|
|
self.assertTrue(result.wasSuccessful())
|
|
self.assertEqual(len(result.errors), 0)
|
|
self.assertEqual(len(result.failures), 0)
|
|
self.assertEqual(result.testsRun, 0)
|
|
self.assertEqual(result.shouldStop, False)
|
|
self.assertIsNone(result._stdout_buffer)
|
|
self.assertIsNone(result._stderr_buffer)
|
|
|
|
# "This method can be called to signal that the set of tests being
|
|
# run should be aborted by setting the TestResult's shouldStop
|
|
# attribute to True."
|
|
def test_stop(self):
|
|
result = unittest.TestResult()
|
|
|
|
result.stop()
|
|
|
|
self.assertEqual(result.shouldStop, True)
|
|
|
|
# "Called when the test case test is about to be run. The default
|
|
# implementation simply increments the instance's testsRun counter."
|
|
def test_startTest(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
pass
|
|
|
|
test = Foo('test_1')
|
|
|
|
result = unittest.TestResult()
|
|
|
|
result.startTest(test)
|
|
|
|
self.assertTrue(result.wasSuccessful())
|
|
self.assertEqual(len(result.errors), 0)
|
|
self.assertEqual(len(result.failures), 0)
|
|
self.assertEqual(result.testsRun, 1)
|
|
self.assertEqual(result.shouldStop, False)
|
|
|
|
result.stopTest(test)
|
|
|
|
# "Called after the test case test has been executed, regardless of
|
|
# the outcome. The default implementation does nothing."
|
|
def test_stopTest(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
pass
|
|
|
|
test = Foo('test_1')
|
|
|
|
result = unittest.TestResult()
|
|
|
|
result.startTest(test)
|
|
|
|
self.assertTrue(result.wasSuccessful())
|
|
self.assertEqual(len(result.errors), 0)
|
|
self.assertEqual(len(result.failures), 0)
|
|
self.assertEqual(result.testsRun, 1)
|
|
self.assertEqual(result.shouldStop, False)
|
|
|
|
result.stopTest(test)
|
|
|
|
# Same tests as above; make sure nothing has changed
|
|
self.assertTrue(result.wasSuccessful())
|
|
self.assertEqual(len(result.errors), 0)
|
|
self.assertEqual(len(result.failures), 0)
|
|
self.assertEqual(result.testsRun, 1)
|
|
self.assertEqual(result.shouldStop, False)
|
|
|
|
# "Called before and after tests are run. The default implementation does nothing."
|
|
def test_startTestRun_stopTestRun(self):
|
|
result = unittest.TestResult()
|
|
result.startTestRun()
|
|
result.stopTestRun()
|
|
|
|
# "addSuccess(test)"
|
|
# ...
|
|
# "Called when the test case test succeeds"
|
|
# ...
|
|
# "wasSuccessful() - Returns True if all tests run so far have passed,
|
|
# otherwise returns False"
|
|
# ...
|
|
# "testsRun - The total number of tests run so far."
|
|
# ...
|
|
# "errors - A list containing 2-tuples of TestCase instances and
|
|
# formatted tracebacks. Each tuple represents a test which raised an
|
|
# unexpected exception. Contains formatted
|
|
# tracebacks instead of sys.exc_info() results."
|
|
# ...
|
|
# "failures - A list containing 2-tuples of TestCase instances and
|
|
# formatted tracebacks. Each tuple represents a test where a failure was
|
|
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
|
|
# methods. Contains formatted tracebacks instead
|
|
# of sys.exc_info() results."
|
|
def test_addSuccess(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
pass
|
|
|
|
test = Foo('test_1')
|
|
|
|
result = unittest.TestResult()
|
|
|
|
result.startTest(test)
|
|
result.addSuccess(test)
|
|
result.stopTest(test)
|
|
|
|
self.assertTrue(result.wasSuccessful())
|
|
self.assertEqual(len(result.errors), 0)
|
|
self.assertEqual(len(result.failures), 0)
|
|
self.assertEqual(result.testsRun, 1)
|
|
self.assertEqual(result.shouldStop, False)
|
|
|
|
# "addFailure(test, err)"
|
|
# ...
|
|
# "Called when the test case test signals a failure. err is a tuple of
|
|
# the form returned by sys.exc_info(): (type, value, traceback)"
|
|
# ...
|
|
# "wasSuccessful() - Returns True if all tests run so far have passed,
|
|
# otherwise returns False"
|
|
# ...
|
|
# "testsRun - The total number of tests run so far."
|
|
# ...
|
|
# "errors - A list containing 2-tuples of TestCase instances and
|
|
# formatted tracebacks. Each tuple represents a test which raised an
|
|
# unexpected exception. Contains formatted
|
|
# tracebacks instead of sys.exc_info() results."
|
|
# ...
|
|
# "failures - A list containing 2-tuples of TestCase instances and
|
|
# formatted tracebacks. Each tuple represents a test where a failure was
|
|
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
|
|
# methods. Contains formatted tracebacks instead
|
|
# of sys.exc_info() results."
|
|
def test_addFailure(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
pass
|
|
|
|
test = Foo('test_1')
|
|
try:
|
|
test.fail("foo")
|
|
except:
|
|
exc_info_tuple = sys.exc_info()
|
|
|
|
result = unittest.TestResult()
|
|
|
|
result.startTest(test)
|
|
result.addFailure(test, exc_info_tuple)
|
|
result.stopTest(test)
|
|
|
|
self.assertFalse(result.wasSuccessful())
|
|
self.assertEqual(len(result.errors), 0)
|
|
self.assertEqual(len(result.failures), 1)
|
|
self.assertEqual(result.testsRun, 1)
|
|
self.assertEqual(result.shouldStop, False)
|
|
|
|
test_case, formatted_exc = result.failures[0]
|
|
self.assertIs(test_case, test)
|
|
self.assertIsInstance(formatted_exc, str)
|
|
|
|
def test_addFailure_filter_traceback_frames(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
pass
|
|
|
|
test = Foo('test_1')
|
|
def get_exc_info():
|
|
try:
|
|
test.fail("foo")
|
|
except:
|
|
return sys.exc_info()
|
|
|
|
exc_info_tuple = get_exc_info()
|
|
|
|
full_exc = traceback.format_exception(*exc_info_tuple)
|
|
|
|
result = unittest.TestResult()
|
|
result.startTest(test)
|
|
result.addFailure(test, exc_info_tuple)
|
|
result.stopTest(test)
|
|
|
|
formatted_exc = result.failures[0][1]
|
|
dropped = [l for l in full_exc if l not in formatted_exc]
|
|
self.assertEqual(len(dropped), 1)
|
|
self.assertIn("raise self.failureException(msg)", dropped[0])
|
|
|
|
def test_addFailure_filter_traceback_frames_context(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
pass
|
|
|
|
test = Foo('test_1')
|
|
def get_exc_info():
|
|
try:
|
|
try:
|
|
test.fail("foo")
|
|
except:
|
|
raise ValueError(42)
|
|
except:
|
|
return sys.exc_info()
|
|
|
|
exc_info_tuple = get_exc_info()
|
|
|
|
full_exc = traceback.format_exception(*exc_info_tuple)
|
|
|
|
result = unittest.TestResult()
|
|
result.startTest(test)
|
|
result.addFailure(test, exc_info_tuple)
|
|
result.stopTest(test)
|
|
|
|
formatted_exc = result.failures[0][1]
|
|
dropped = [l for l in full_exc if l not in formatted_exc]
|
|
self.assertEqual(len(dropped), 1)
|
|
self.assertIn("raise self.failureException(msg)", dropped[0])
|
|
|
|
def test_addFailure_filter_traceback_frames_chained_exception_self_loop(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
pass
|
|
|
|
def get_exc_info():
|
|
try:
|
|
loop = Exception("Loop")
|
|
loop.__cause__ = loop
|
|
loop.__context__ = loop
|
|
raise loop
|
|
except:
|
|
return sys.exc_info()
|
|
|
|
exc_info_tuple = get_exc_info()
|
|
|
|
test = Foo('test_1')
|
|
result = unittest.TestResult()
|
|
result.startTest(test)
|
|
result.addFailure(test, exc_info_tuple)
|
|
result.stopTest(test)
|
|
|
|
formatted_exc = result.failures[0][1]
|
|
self.assertEqual(formatted_exc.count("Exception: Loop\n"), 1)
|
|
|
|
def test_addFailure_filter_traceback_frames_chained_exception_cycle(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
pass
|
|
|
|
def get_exc_info():
|
|
try:
|
|
# Create two directionally opposed cycles
|
|
# __cause__ in one direction, __context__ in the other
|
|
A, B, C = Exception("A"), Exception("B"), Exception("C")
|
|
edges = [(C, B), (B, A), (A, C)]
|
|
for ex1, ex2 in edges:
|
|
ex1.__cause__ = ex2
|
|
ex2.__context__ = ex1
|
|
raise C
|
|
except:
|
|
return sys.exc_info()
|
|
|
|
exc_info_tuple = get_exc_info()
|
|
|
|
test = Foo('test_1')
|
|
result = unittest.TestResult()
|
|
result.startTest(test)
|
|
result.addFailure(test, exc_info_tuple)
|
|
result.stopTest(test)
|
|
|
|
formatted_exc = result.failures[0][1]
|
|
self.assertEqual(formatted_exc.count("Exception: A\n"), 1)
|
|
self.assertEqual(formatted_exc.count("Exception: B\n"), 1)
|
|
self.assertEqual(formatted_exc.count("Exception: C\n"), 1)
|
|
|
|
# "addError(test, err)"
|
|
# ...
|
|
# "Called when the test case test raises an unexpected exception err
|
|
# is a tuple of the form returned by sys.exc_info():
|
|
# (type, value, traceback)"
|
|
# ...
|
|
# "wasSuccessful() - Returns True if all tests run so far have passed,
|
|
# otherwise returns False"
|
|
# ...
|
|
# "testsRun - The total number of tests run so far."
|
|
# ...
|
|
# "errors - A list containing 2-tuples of TestCase instances and
|
|
# formatted tracebacks. Each tuple represents a test which raised an
|
|
# unexpected exception. Contains formatted
|
|
# tracebacks instead of sys.exc_info() results."
|
|
# ...
|
|
# "failures - A list containing 2-tuples of TestCase instances and
|
|
# formatted tracebacks. Each tuple represents a test where a failure was
|
|
# explicitly signalled using the TestCase.fail*() or TestCase.assert*()
|
|
# methods. Contains formatted tracebacks instead
|
|
# of sys.exc_info() results."
|
|
def test_addError(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
pass
|
|
|
|
test = Foo('test_1')
|
|
try:
|
|
raise TypeError()
|
|
except:
|
|
exc_info_tuple = sys.exc_info()
|
|
|
|
result = unittest.TestResult()
|
|
|
|
result.startTest(test)
|
|
result.addError(test, exc_info_tuple)
|
|
result.stopTest(test)
|
|
|
|
self.assertFalse(result.wasSuccessful())
|
|
self.assertEqual(len(result.errors), 1)
|
|
self.assertEqual(len(result.failures), 0)
|
|
self.assertEqual(result.testsRun, 1)
|
|
self.assertEqual(result.shouldStop, False)
|
|
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertIs(test_case, test)
|
|
self.assertIsInstance(formatted_exc, str)
|
|
|
|
def test_addError_locals(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
1/0
|
|
|
|
test = Foo('test_1')
|
|
result = unittest.TestResult()
|
|
result.tb_locals = True
|
|
|
|
unittest.result.traceback = MockTraceback
|
|
self.addCleanup(restore_traceback)
|
|
result.startTestRun()
|
|
test.run(result)
|
|
result.stopTestRun()
|
|
|
|
self.assertEqual(len(result.errors), 1)
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual('A tracebacklocals', formatted_exc)
|
|
|
|
def test_addSubTest(self):
|
|
class Foo(unittest.TestCase):
|
|
def test_1(self):
|
|
nonlocal subtest
|
|
with self.subTest(foo=1):
|
|
subtest = self._subtest
|
|
try:
|
|
1/0
|
|
except ZeroDivisionError:
|
|
exc_info_tuple = sys.exc_info()
|
|
# Register an error by hand (to check the API)
|
|
result.addSubTest(test, subtest, exc_info_tuple)
|
|
# Now trigger a failure
|
|
self.fail("some recognizable failure")
|
|
|
|
subtest = None
|
|
test = Foo('test_1')
|
|
result = unittest.TestResult()
|
|
|
|
test.run(result)
|
|
|
|
self.assertFalse(result.wasSuccessful())
|
|
self.assertEqual(len(result.errors), 1)
|
|
self.assertEqual(len(result.failures), 1)
|
|
self.assertEqual(result.testsRun, 1)
|
|
self.assertEqual(result.shouldStop, False)
|
|
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertIs(test_case, subtest)
|
|
self.assertIn("ZeroDivisionError", formatted_exc)
|
|
test_case, formatted_exc = result.failures[0]
|
|
self.assertIs(test_case, subtest)
|
|
self.assertIn("some recognizable failure", formatted_exc)
|
|
|
|
def testStackFrameTrimming(self):
|
|
class Frame(object):
|
|
class tb_frame(object):
|
|
f_globals = {}
|
|
result = unittest.TestResult()
|
|
self.assertFalse(result._is_relevant_tb_level(Frame))
|
|
|
|
Frame.tb_frame.f_globals['__unittest'] = True
|
|
self.assertTrue(result._is_relevant_tb_level(Frame))
|
|
|
|
def testFailFast(self):
|
|
result = unittest.TestResult()
|
|
result._exc_info_to_string = lambda *_: ''
|
|
result.failfast = True
|
|
result.addError(None, None)
|
|
self.assertTrue(result.shouldStop)
|
|
|
|
result = unittest.TestResult()
|
|
result._exc_info_to_string = lambda *_: ''
|
|
result.failfast = True
|
|
result.addFailure(None, None)
|
|
self.assertTrue(result.shouldStop)
|
|
|
|
result = unittest.TestResult()
|
|
result._exc_info_to_string = lambda *_: ''
|
|
result.failfast = True
|
|
result.addUnexpectedSuccess(None)
|
|
self.assertTrue(result.shouldStop)
|
|
|
|
def testFailFastSetByRunner(self):
|
|
stream = BufferedWriter()
|
|
runner = unittest.TextTestRunner(stream=stream, failfast=True)
|
|
def test(result):
|
|
self.assertTrue(result.failfast)
|
|
result = runner.run(test)
|
|
stream.flush()
|
|
self.assertTrue(stream.getvalue().endswith('\n\nOK\n'))
|
|
|
|
|
|
class Test_TextTestResult(unittest.TestCase):
|
|
maxDiff = None
|
|
|
|
def testGetDescriptionWithoutDocstring(self):
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
self.assertEqual(
|
|
result.getDescription(self),
|
|
'testGetDescriptionWithoutDocstring (' + __name__ +
|
|
'.Test_TextTestResult.testGetDescriptionWithoutDocstring)')
|
|
|
|
def testGetSubTestDescriptionWithoutDocstring(self):
|
|
with self.subTest(foo=1, bar=2):
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
self.assertEqual(
|
|
result.getDescription(self._subtest),
|
|
'testGetSubTestDescriptionWithoutDocstring (' + __name__ +
|
|
'.Test_TextTestResult.testGetSubTestDescriptionWithoutDocstring) (foo=1, bar=2)')
|
|
|
|
with self.subTest('some message'):
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
self.assertEqual(
|
|
result.getDescription(self._subtest),
|
|
'testGetSubTestDescriptionWithoutDocstring (' + __name__ +
|
|
'.Test_TextTestResult.testGetSubTestDescriptionWithoutDocstring) [some message]')
|
|
|
|
def testGetSubTestDescriptionWithoutDocstringAndParams(self):
|
|
with self.subTest():
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
self.assertEqual(
|
|
result.getDescription(self._subtest),
|
|
'testGetSubTestDescriptionWithoutDocstringAndParams '
|
|
'(' + __name__ + '.Test_TextTestResult.testGetSubTestDescriptionWithoutDocstringAndParams) '
|
|
'(<subtest>)')
|
|
|
|
def testGetSubTestDescriptionForFalseValues(self):
|
|
expected = 'testGetSubTestDescriptionForFalseValues (%s.Test_TextTestResult.testGetSubTestDescriptionForFalseValues) [%s]'
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
for arg in [0, None, []]:
|
|
with self.subTest(arg):
|
|
self.assertEqual(
|
|
result.getDescription(self._subtest),
|
|
expected % (__name__, arg)
|
|
)
|
|
|
|
def testGetNestedSubTestDescriptionWithoutDocstring(self):
|
|
with self.subTest(foo=1):
|
|
with self.subTest(baz=2, bar=3):
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
self.assertEqual(
|
|
result.getDescription(self._subtest),
|
|
'testGetNestedSubTestDescriptionWithoutDocstring '
|
|
'(' + __name__ + '.Test_TextTestResult.testGetNestedSubTestDescriptionWithoutDocstring) '
|
|
'(baz=2, bar=3, foo=1)')
|
|
|
|
def testGetDuplicatedNestedSubTestDescriptionWithoutDocstring(self):
|
|
with self.subTest(foo=1, bar=2):
|
|
with self.subTest(baz=3, bar=4):
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
self.assertEqual(
|
|
result.getDescription(self._subtest),
|
|
'testGetDuplicatedNestedSubTestDescriptionWithoutDocstring '
|
|
'(' + __name__ + '.Test_TextTestResult.testGetDuplicatedNestedSubTestDescriptionWithoutDocstring) (baz=3, bar=4, foo=1)')
|
|
|
|
@unittest.skipIf(sys.flags.optimize >= 2,
|
|
"Docstrings are omitted with -O2 and above")
|
|
def testGetDescriptionWithOneLineDocstring(self):
|
|
"""Tests getDescription() for a method with a docstring."""
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
self.assertEqual(
|
|
result.getDescription(self),
|
|
('testGetDescriptionWithOneLineDocstring '
|
|
'(' + __name__ + '.Test_TextTestResult.testGetDescriptionWithOneLineDocstring)\n'
|
|
'Tests getDescription() for a method with a docstring.'))
|
|
|
|
@unittest.skipIf(sys.flags.optimize >= 2,
|
|
"Docstrings are omitted with -O2 and above")
|
|
def testGetSubTestDescriptionWithOneLineDocstring(self):
|
|
"""Tests getDescription() for a method with a docstring."""
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
with self.subTest(foo=1, bar=2):
|
|
self.assertEqual(
|
|
result.getDescription(self._subtest),
|
|
('testGetSubTestDescriptionWithOneLineDocstring '
|
|
'(' + __name__ + '.Test_TextTestResult.testGetSubTestDescriptionWithOneLineDocstring) '
|
|
'(foo=1, bar=2)\n'
|
|
|
|
'Tests getDescription() for a method with a docstring.'))
|
|
|
|
@unittest.skipIf(sys.flags.optimize >= 2,
|
|
"Docstrings are omitted with -O2 and above")
|
|
def testGetDescriptionWithMultiLineDocstring(self):
|
|
"""Tests getDescription() for a method with a longer docstring.
|
|
The second line of the docstring.
|
|
"""
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
self.assertEqual(
|
|
result.getDescription(self),
|
|
('testGetDescriptionWithMultiLineDocstring '
|
|
'(' + __name__ + '.Test_TextTestResult.testGetDescriptionWithMultiLineDocstring)\n'
|
|
'Tests getDescription() for a method with a longer '
|
|
'docstring.'))
|
|
|
|
@unittest.skipIf(sys.flags.optimize >= 2,
|
|
"Docstrings are omitted with -O2 and above")
|
|
def testGetSubTestDescriptionWithMultiLineDocstring(self):
|
|
"""Tests getDescription() for a method with a longer docstring.
|
|
The second line of the docstring.
|
|
"""
|
|
result = unittest.TextTestResult(None, True, 1)
|
|
with self.subTest(foo=1, bar=2):
|
|
self.assertEqual(
|
|
result.getDescription(self._subtest),
|
|
('testGetSubTestDescriptionWithMultiLineDocstring '
|
|
'(' + __name__ + '.Test_TextTestResult.testGetSubTestDescriptionWithMultiLineDocstring) '
|
|
'(foo=1, bar=2)\n'
|
|
'Tests getDescription() for a method with a longer '
|
|
'docstring.'))
|
|
|
|
class Test(unittest.TestCase):
|
|
def testSuccess(self):
|
|
pass
|
|
def testSkip(self):
|
|
self.skipTest('skip')
|
|
def testFail(self):
|
|
self.fail('fail')
|
|
def testError(self):
|
|
raise Exception('error')
|
|
@unittest.expectedFailure
|
|
def testExpectedFailure(self):
|
|
self.fail('fail')
|
|
@unittest.expectedFailure
|
|
def testUnexpectedSuccess(self):
|
|
pass
|
|
def testSubTestSuccess(self):
|
|
with self.subTest('one', a=1):
|
|
pass
|
|
with self.subTest('two', b=2):
|
|
pass
|
|
def testSubTestMixed(self):
|
|
with self.subTest('success', a=1):
|
|
pass
|
|
with self.subTest('skip', b=2):
|
|
self.skipTest('skip')
|
|
with self.subTest('fail', c=3):
|
|
self.fail('fail')
|
|
with self.subTest('error', d=4):
|
|
raise Exception('error')
|
|
|
|
tearDownError = None
|
|
def tearDown(self):
|
|
if self.tearDownError is not None:
|
|
raise self.tearDownError
|
|
|
|
def _run_test(self, test_name, verbosity, tearDownError=None):
|
|
stream = BufferedWriter()
|
|
stream = unittest.runner._WritelnDecorator(stream)
|
|
result = unittest.TextTestResult(stream, True, verbosity)
|
|
test = self.Test(test_name)
|
|
test.tearDownError = tearDownError
|
|
test.run(result)
|
|
return stream.getvalue()
|
|
|
|
def testDotsOutput(self):
|
|
self.assertEqual(self._run_test('testSuccess', 1), '.')
|
|
self.assertEqual(self._run_test('testSkip', 1), 's')
|
|
self.assertEqual(self._run_test('testFail', 1), 'F')
|
|
self.assertEqual(self._run_test('testError', 1), 'E')
|
|
self.assertEqual(self._run_test('testExpectedFailure', 1), 'x')
|
|
self.assertEqual(self._run_test('testUnexpectedSuccess', 1), 'u')
|
|
|
|
def testLongOutput(self):
|
|
classname = f'{__name__}.{self.Test.__qualname__}'
|
|
self.assertEqual(self._run_test('testSuccess', 2),
|
|
f'testSuccess ({classname}.testSuccess) ... ok\n')
|
|
self.assertEqual(self._run_test('testSkip', 2),
|
|
f"testSkip ({classname}.testSkip) ... skipped 'skip'\n")
|
|
self.assertEqual(self._run_test('testFail', 2),
|
|
f'testFail ({classname}.testFail) ... FAIL\n')
|
|
self.assertEqual(self._run_test('testError', 2),
|
|
f'testError ({classname}.testError) ... ERROR\n')
|
|
self.assertEqual(self._run_test('testExpectedFailure', 2),
|
|
f'testExpectedFailure ({classname}.testExpectedFailure) ... expected failure\n')
|
|
self.assertEqual(self._run_test('testUnexpectedSuccess', 2),
|
|
f'testUnexpectedSuccess ({classname}.testUnexpectedSuccess) ... unexpected success\n')
|
|
|
|
def testDotsOutputSubTestSuccess(self):
|
|
self.assertEqual(self._run_test('testSubTestSuccess', 1), '.')
|
|
|
|
def testLongOutputSubTestSuccess(self):
|
|
classname = f'{__name__}.{self.Test.__qualname__}'
|
|
self.assertEqual(self._run_test('testSubTestSuccess', 2),
|
|
f'testSubTestSuccess ({classname}.testSubTestSuccess) ... ok\n')
|
|
|
|
def testDotsOutputSubTestMixed(self):
|
|
self.assertEqual(self._run_test('testSubTestMixed', 1), 'sFE')
|
|
|
|
def testLongOutputSubTestMixed(self):
|
|
classname = f'{__name__}.{self.Test.__qualname__}'
|
|
self.assertEqual(self._run_test('testSubTestMixed', 2),
|
|
f'testSubTestMixed ({classname}.testSubTestMixed) ... \n'
|
|
f" testSubTestMixed ({classname}.testSubTestMixed) [skip] (b=2) ... skipped 'skip'\n"
|
|
f' testSubTestMixed ({classname}.testSubTestMixed) [fail] (c=3) ... FAIL\n'
|
|
f' testSubTestMixed ({classname}.testSubTestMixed) [error] (d=4) ... ERROR\n')
|
|
|
|
def testDotsOutputTearDownFail(self):
|
|
out = self._run_test('testSuccess', 1, AssertionError('fail'))
|
|
self.assertEqual(out, 'F')
|
|
out = self._run_test('testError', 1, AssertionError('fail'))
|
|
self.assertEqual(out, 'EF')
|
|
out = self._run_test('testFail', 1, Exception('error'))
|
|
self.assertEqual(out, 'FE')
|
|
out = self._run_test('testSkip', 1, AssertionError('fail'))
|
|
self.assertEqual(out, 'sF')
|
|
|
|
def testLongOutputTearDownFail(self):
|
|
classname = f'{__name__}.{self.Test.__qualname__}'
|
|
out = self._run_test('testSuccess', 2, AssertionError('fail'))
|
|
self.assertEqual(out,
|
|
f'testSuccess ({classname}.testSuccess) ... FAIL\n')
|
|
out = self._run_test('testError', 2, AssertionError('fail'))
|
|
self.assertEqual(out,
|
|
f'testError ({classname}.testError) ... ERROR\n'
|
|
f'testError ({classname}.testError) ... FAIL\n')
|
|
out = self._run_test('testFail', 2, Exception('error'))
|
|
self.assertEqual(out,
|
|
f'testFail ({classname}.testFail) ... FAIL\n'
|
|
f'testFail ({classname}.testFail) ... ERROR\n')
|
|
out = self._run_test('testSkip', 2, AssertionError('fail'))
|
|
self.assertEqual(out,
|
|
f"testSkip ({classname}.testSkip) ... skipped 'skip'\n"
|
|
f'testSkip ({classname}.testSkip) ... FAIL\n')
|
|
|
|
|
|
classDict = dict(unittest.TestResult.__dict__)
|
|
for m in ('addSkip', 'addExpectedFailure', 'addUnexpectedSuccess',
|
|
'__init__'):
|
|
del classDict[m]
|
|
|
|
def __init__(self, stream=None, descriptions=None, verbosity=None):
|
|
self.failures = []
|
|
self.errors = []
|
|
self.testsRun = 0
|
|
self.shouldStop = False
|
|
self.buffer = False
|
|
self.tb_locals = False
|
|
|
|
classDict['__init__'] = __init__
|
|
OldResult = type('OldResult', (object,), classDict)
|
|
|
|
class Test_OldTestResult(unittest.TestCase):
|
|
|
|
def assertOldResultWarning(self, test, failures):
|
|
with warnings_helper.check_warnings(
|
|
("TestResult has no add.+ method,", RuntimeWarning)):
|
|
result = OldResult()
|
|
test.run(result)
|
|
self.assertEqual(len(result.failures), failures)
|
|
|
|
def testOldTestResult(self):
|
|
class Test(unittest.TestCase):
|
|
def testSkip(self):
|
|
self.skipTest('foobar')
|
|
@unittest.expectedFailure
|
|
def testExpectedFail(self):
|
|
raise TypeError
|
|
@unittest.expectedFailure
|
|
def testUnexpectedSuccess(self):
|
|
pass
|
|
|
|
for test_name, should_pass in (('testSkip', True),
|
|
('testExpectedFail', True),
|
|
('testUnexpectedSuccess', False)):
|
|
test = Test(test_name)
|
|
self.assertOldResultWarning(test, int(not should_pass))
|
|
|
|
def testOldTestTesultSetup(self):
|
|
class Test(unittest.TestCase):
|
|
def setUp(self):
|
|
self.skipTest('no reason')
|
|
def testFoo(self):
|
|
pass
|
|
self.assertOldResultWarning(Test('testFoo'), 0)
|
|
|
|
def testOldTestResultClass(self):
|
|
@unittest.skip('no reason')
|
|
class Test(unittest.TestCase):
|
|
def testFoo(self):
|
|
pass
|
|
self.assertOldResultWarning(Test('testFoo'), 0)
|
|
|
|
def testOldResultWithRunner(self):
|
|
class Test(unittest.TestCase):
|
|
def testFoo(self):
|
|
pass
|
|
runner = unittest.TextTestRunner(resultclass=OldResult,
|
|
stream=io.StringIO())
|
|
# This will raise an exception if TextTestRunner can't handle old
|
|
# test result objects
|
|
runner.run(Test('testFoo'))
|
|
|
|
|
|
class TestOutputBuffering(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
self._real_out = sys.stdout
|
|
self._real_err = sys.stderr
|
|
|
|
def tearDown(self):
|
|
sys.stdout = self._real_out
|
|
sys.stderr = self._real_err
|
|
|
|
def testBufferOutputOff(self):
|
|
real_out = self._real_out
|
|
real_err = self._real_err
|
|
|
|
result = unittest.TestResult()
|
|
self.assertFalse(result.buffer)
|
|
|
|
self.assertIs(real_out, sys.stdout)
|
|
self.assertIs(real_err, sys.stderr)
|
|
|
|
result.startTest(self)
|
|
|
|
self.assertIs(real_out, sys.stdout)
|
|
self.assertIs(real_err, sys.stderr)
|
|
|
|
def testBufferOutputStartTestAddSuccess(self):
|
|
real_out = self._real_out
|
|
real_err = self._real_err
|
|
|
|
result = unittest.TestResult()
|
|
self.assertFalse(result.buffer)
|
|
|
|
result.buffer = True
|
|
|
|
self.assertIs(real_out, sys.stdout)
|
|
self.assertIs(real_err, sys.stderr)
|
|
|
|
result.startTest(self)
|
|
|
|
self.assertIsNot(real_out, sys.stdout)
|
|
self.assertIsNot(real_err, sys.stderr)
|
|
self.assertIsInstance(sys.stdout, io.StringIO)
|
|
self.assertIsInstance(sys.stderr, io.StringIO)
|
|
self.assertIsNot(sys.stdout, sys.stderr)
|
|
|
|
out_stream = sys.stdout
|
|
err_stream = sys.stderr
|
|
|
|
result._original_stdout = io.StringIO()
|
|
result._original_stderr = io.StringIO()
|
|
|
|
print('foo')
|
|
print('bar', file=sys.stderr)
|
|
|
|
self.assertEqual(out_stream.getvalue(), 'foo\n')
|
|
self.assertEqual(err_stream.getvalue(), 'bar\n')
|
|
|
|
self.assertEqual(result._original_stdout.getvalue(), '')
|
|
self.assertEqual(result._original_stderr.getvalue(), '')
|
|
|
|
result.addSuccess(self)
|
|
result.stopTest(self)
|
|
|
|
self.assertIs(sys.stdout, result._original_stdout)
|
|
self.assertIs(sys.stderr, result._original_stderr)
|
|
|
|
self.assertEqual(result._original_stdout.getvalue(), '')
|
|
self.assertEqual(result._original_stderr.getvalue(), '')
|
|
|
|
self.assertEqual(out_stream.getvalue(), '')
|
|
self.assertEqual(err_stream.getvalue(), '')
|
|
|
|
|
|
def getStartedResult(self):
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
result.startTest(self)
|
|
return result
|
|
|
|
def testBufferOutputAddErrorOrFailure(self):
|
|
unittest.result.traceback = MockTraceback
|
|
self.addCleanup(restore_traceback)
|
|
|
|
for message_attr, add_attr, include_error in [
|
|
('errors', 'addError', True),
|
|
('failures', 'addFailure', False),
|
|
('errors', 'addError', True),
|
|
('failures', 'addFailure', False)
|
|
]:
|
|
result = self.getStartedResult()
|
|
buffered_out = sys.stdout
|
|
buffered_err = sys.stderr
|
|
result._original_stdout = io.StringIO()
|
|
result._original_stderr = io.StringIO()
|
|
|
|
print('foo', file=sys.stdout)
|
|
if include_error:
|
|
print('bar', file=sys.stderr)
|
|
|
|
|
|
addFunction = getattr(result, add_attr)
|
|
addFunction(self, (None, None, None))
|
|
result.stopTest(self)
|
|
|
|
result_list = getattr(result, message_attr)
|
|
self.assertEqual(len(result_list), 1)
|
|
|
|
test, message = result_list[0]
|
|
expectedOutMessage = textwrap.dedent("""
|
|
Stdout:
|
|
foo
|
|
""")
|
|
expectedErrMessage = ''
|
|
if include_error:
|
|
expectedErrMessage = textwrap.dedent("""
|
|
Stderr:
|
|
bar
|
|
""")
|
|
|
|
expectedFullMessage = 'A traceback%s%s' % (expectedOutMessage, expectedErrMessage)
|
|
|
|
self.assertIs(test, self)
|
|
self.assertEqual(result._original_stdout.getvalue(), expectedOutMessage)
|
|
self.assertEqual(result._original_stderr.getvalue(), expectedErrMessage)
|
|
self.assertMultiLineEqual(message, expectedFullMessage)
|
|
|
|
def testBufferSetUp(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
def setUp(self):
|
|
print('set up')
|
|
1/0
|
|
def test_foo(self):
|
|
pass
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\nset up\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 1)
|
|
description = f'test_foo ({strclass(Foo)}.test_foo)'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(str(test_case), description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferTearDown(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
def tearDown(self):
|
|
print('tear down')
|
|
1/0
|
|
def test_foo(self):
|
|
pass
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\ntear down\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 1)
|
|
description = f'test_foo ({strclass(Foo)}.test_foo)'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(str(test_case), description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferDoCleanups(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
def setUp(self):
|
|
print('set up')
|
|
self.addCleanup(bad_cleanup1)
|
|
self.addCleanup(bad_cleanup2)
|
|
def test_foo(self):
|
|
pass
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\nset up\ndo cleanup2\ndo cleanup1\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 2)
|
|
description = f'test_foo ({strclass(Foo)}.test_foo)'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(str(test_case), description)
|
|
self.assertIn('ValueError: bad cleanup2', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn('\nStdout:\nset up\ndo cleanup2\n', formatted_exc)
|
|
self.assertNotIn('\ndo cleanup1\n', formatted_exc)
|
|
test_case, formatted_exc = result.errors[1]
|
|
self.assertEqual(str(test_case), description)
|
|
self.assertIn('TypeError: bad cleanup1', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferSetUp_DoCleanups(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
def setUp(self):
|
|
print('set up')
|
|
self.addCleanup(bad_cleanup1)
|
|
self.addCleanup(bad_cleanup2)
|
|
1/0
|
|
def test_foo(self):
|
|
pass
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\nset up\ndo cleanup2\ndo cleanup1\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 3)
|
|
description = f'test_foo ({strclass(Foo)}.test_foo)'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(str(test_case), description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn('\nStdout:\nset up\n', formatted_exc)
|
|
self.assertNotIn('\ndo cleanup2\n', formatted_exc)
|
|
self.assertNotIn('\ndo cleanup1\n', formatted_exc)
|
|
test_case, formatted_exc = result.errors[1]
|
|
self.assertEqual(str(test_case), description)
|
|
self.assertIn('ValueError: bad cleanup2', formatted_exc)
|
|
self.assertNotIn('ZeroDivisionError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn('\nStdout:\nset up\ndo cleanup2\n', formatted_exc)
|
|
self.assertNotIn('\ndo cleanup1\n', formatted_exc)
|
|
test_case, formatted_exc = result.errors[2]
|
|
self.assertEqual(str(test_case), description)
|
|
self.assertIn('TypeError: bad cleanup1', formatted_exc)
|
|
self.assertNotIn('ZeroDivisionError', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferTearDown_DoCleanups(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
def setUp(self):
|
|
print('set up')
|
|
self.addCleanup(bad_cleanup1)
|
|
self.addCleanup(bad_cleanup2)
|
|
def tearDown(self):
|
|
print('tear down')
|
|
1/0
|
|
def test_foo(self):
|
|
pass
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\nset up\ntear down\ndo cleanup2\ndo cleanup1\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 3)
|
|
description = f'test_foo ({strclass(Foo)}.test_foo)'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(str(test_case), description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn('\nStdout:\nset up\ntear down\n', formatted_exc)
|
|
self.assertNotIn('\ndo cleanup2\n', formatted_exc)
|
|
self.assertNotIn('\ndo cleanup1\n', formatted_exc)
|
|
test_case, formatted_exc = result.errors[1]
|
|
self.assertEqual(str(test_case), description)
|
|
self.assertIn('ValueError: bad cleanup2', formatted_exc)
|
|
self.assertNotIn('ZeroDivisionError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn('\nStdout:\nset up\ntear down\ndo cleanup2\n', formatted_exc)
|
|
self.assertNotIn('\ndo cleanup1\n', formatted_exc)
|
|
test_case, formatted_exc = result.errors[2]
|
|
self.assertEqual(str(test_case), description)
|
|
self.assertIn('TypeError: bad cleanup1', formatted_exc)
|
|
self.assertNotIn('ZeroDivisionError', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferSetupClass(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
print('set up class')
|
|
1/0
|
|
def test_foo(self):
|
|
pass
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\nset up class\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 1)
|
|
description = f'setUpClass ({strclass(Foo)})'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferTearDownClass(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
print('tear down class')
|
|
1/0
|
|
def test_foo(self):
|
|
pass
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\ntear down class\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 1)
|
|
description = f'tearDownClass ({strclass(Foo)})'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferDoClassCleanups(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
print('set up class')
|
|
cls.addClassCleanup(bad_cleanup1)
|
|
cls.addClassCleanup(bad_cleanup2)
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
print('tear down class')
|
|
def test_foo(self):
|
|
pass
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\ntear down class\ndo cleanup2\ndo cleanup1\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 2)
|
|
description = f'tearDownClass ({strclass(Foo)})'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ValueError: bad cleanup2', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
test_case, formatted_exc = result.errors[1]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('TypeError: bad cleanup1', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferSetupClass_DoClassCleanups(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
print('set up class')
|
|
cls.addClassCleanup(bad_cleanup1)
|
|
cls.addClassCleanup(bad_cleanup2)
|
|
1/0
|
|
def test_foo(self):
|
|
pass
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\nset up class\ndo cleanup2\ndo cleanup1\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 3)
|
|
description = f'setUpClass ({strclass(Foo)})'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn('\nStdout:\nset up class\n', formatted_exc)
|
|
test_case, formatted_exc = result.errors[1]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ValueError: bad cleanup2', formatted_exc)
|
|
self.assertNotIn('ZeroDivisionError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
test_case, formatted_exc = result.errors[2]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('TypeError: bad cleanup1', formatted_exc)
|
|
self.assertNotIn('ZeroDivisionError', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferTearDownClass_DoClassCleanups(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
print('set up class')
|
|
cls.addClassCleanup(bad_cleanup1)
|
|
cls.addClassCleanup(bad_cleanup2)
|
|
@classmethod
|
|
def tearDownClass(cls):
|
|
print('tear down class')
|
|
1/0
|
|
def test_foo(self):
|
|
pass
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\ntear down class\ndo cleanup2\ndo cleanup1\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 3)
|
|
description = f'tearDownClass ({strclass(Foo)})'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn('\nStdout:\ntear down class\n', formatted_exc)
|
|
test_case, formatted_exc = result.errors[1]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ValueError: bad cleanup2', formatted_exc)
|
|
self.assertNotIn('ZeroDivisionError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
test_case, formatted_exc = result.errors[2]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('TypeError: bad cleanup1', formatted_exc)
|
|
self.assertNotIn('ZeroDivisionError', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferSetUpModule(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
def test_foo(self):
|
|
pass
|
|
class Module(object):
|
|
@staticmethod
|
|
def setUpModule():
|
|
print('set up module')
|
|
1/0
|
|
|
|
Foo.__module__ = 'Module'
|
|
sys.modules['Module'] = Module
|
|
self.addCleanup(sys.modules.pop, 'Module')
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\nset up module\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 1)
|
|
description = 'setUpModule (Module)'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferTearDownModule(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
def test_foo(self):
|
|
pass
|
|
class Module(object):
|
|
@staticmethod
|
|
def tearDownModule():
|
|
print('tear down module')
|
|
1/0
|
|
|
|
Foo.__module__ = 'Module'
|
|
sys.modules['Module'] = Module
|
|
self.addCleanup(sys.modules.pop, 'Module')
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\ntear down module\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 1)
|
|
description = 'tearDownModule (Module)'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferDoModuleCleanups(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
def test_foo(self):
|
|
pass
|
|
class Module(object):
|
|
@staticmethod
|
|
def setUpModule():
|
|
print('set up module')
|
|
unittest.addModuleCleanup(bad_cleanup1)
|
|
unittest.addModuleCleanup(bad_cleanup2)
|
|
|
|
Foo.__module__ = 'Module'
|
|
sys.modules['Module'] = Module
|
|
self.addCleanup(sys.modules.pop, 'Module')
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\ndo cleanup2\ndo cleanup1\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 1)
|
|
description = 'tearDownModule (Module)'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ValueError: bad cleanup2', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferSetUpModule_DoModuleCleanups(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
def test_foo(self):
|
|
pass
|
|
class Module(object):
|
|
@staticmethod
|
|
def setUpModule():
|
|
print('set up module')
|
|
unittest.addModuleCleanup(bad_cleanup1)
|
|
unittest.addModuleCleanup(bad_cleanup2)
|
|
1/0
|
|
|
|
Foo.__module__ = 'Module'
|
|
sys.modules['Module'] = Module
|
|
self.addCleanup(sys.modules.pop, 'Module')
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\nset up module\ndo cleanup2\ndo cleanup1\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 2)
|
|
description = 'setUpModule (Module)'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn('\nStdout:\nset up module\n', formatted_exc)
|
|
test_case, formatted_exc = result.errors[1]
|
|
self.assertIn(expected_out, formatted_exc)
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ValueError: bad cleanup2', formatted_exc)
|
|
self.assertNotIn('ZeroDivisionError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
def testBufferTearDownModule_DoModuleCleanups(self):
|
|
with captured_stdout() as stdout:
|
|
result = unittest.TestResult()
|
|
result.buffer = True
|
|
|
|
class Foo(unittest.TestCase):
|
|
def test_foo(self):
|
|
pass
|
|
class Module(object):
|
|
@staticmethod
|
|
def setUpModule():
|
|
print('set up module')
|
|
unittest.addModuleCleanup(bad_cleanup1)
|
|
unittest.addModuleCleanup(bad_cleanup2)
|
|
@staticmethod
|
|
def tearDownModule():
|
|
print('tear down module')
|
|
1/0
|
|
|
|
Foo.__module__ = 'Module'
|
|
sys.modules['Module'] = Module
|
|
self.addCleanup(sys.modules.pop, 'Module')
|
|
suite = unittest.TestSuite([Foo('test_foo')])
|
|
suite(result)
|
|
expected_out = '\nStdout:\ntear down module\ndo cleanup2\ndo cleanup1\n'
|
|
self.assertEqual(stdout.getvalue(), expected_out)
|
|
self.assertEqual(len(result.errors), 2)
|
|
description = 'tearDownModule (Module)'
|
|
test_case, formatted_exc = result.errors[0]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ZeroDivisionError: division by zero', formatted_exc)
|
|
self.assertNotIn('ValueError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn('\nStdout:\ntear down module\n', formatted_exc)
|
|
test_case, formatted_exc = result.errors[1]
|
|
self.assertEqual(test_case.description, description)
|
|
self.assertIn('ValueError: bad cleanup2', formatted_exc)
|
|
self.assertNotIn('ZeroDivisionError', formatted_exc)
|
|
self.assertNotIn('TypeError', formatted_exc)
|
|
self.assertIn(expected_out, formatted_exc)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|