1import io 2import sys 3import textwrap 4 5from test.support import warnings_helper, captured_stdout 6 7import traceback 8import unittest 9from unittest.util import strclass 10from test.test_unittest.support import BufferedWriter 11 12 13class MockTraceback(object): 14 class TracebackException: 15 def __init__(self, *args, **kwargs): 16 self.capture_locals = kwargs.get('capture_locals', False) 17 def format(self): 18 result = ['A traceback'] 19 if self.capture_locals: 20 result.append('locals') 21 return result 22 23def restore_traceback(): 24 unittest.result.traceback = traceback 25 26 27def bad_cleanup1(): 28 print('do cleanup1') 29 raise TypeError('bad cleanup1') 30 31 32def bad_cleanup2(): 33 print('do cleanup2') 34 raise ValueError('bad cleanup2') 35 36 37class Test_TestResult(unittest.TestCase): 38 # Note: there are not separate tests for TestResult.wasSuccessful(), 39 # TestResult.errors, TestResult.failures, TestResult.testsRun or 40 # TestResult.shouldStop because these only have meaning in terms of 41 # other TestResult methods. 42 # 43 # Accordingly, tests for the aforenamed attributes are incorporated 44 # in with the tests for the defining methods. 45 ################################################################ 46 47 def test_init(self): 48 result = unittest.TestResult() 49 50 self.assertTrue(result.wasSuccessful()) 51 self.assertEqual(len(result.errors), 0) 52 self.assertEqual(len(result.failures), 0) 53 self.assertEqual(result.testsRun, 0) 54 self.assertEqual(result.shouldStop, False) 55 self.assertIsNone(result._stdout_buffer) 56 self.assertIsNone(result._stderr_buffer) 57 58 # "This method can be called to signal that the set of tests being 59 # run should be aborted by setting the TestResult's shouldStop 60 # attribute to True." 61 def test_stop(self): 62 result = unittest.TestResult() 63 64 result.stop() 65 66 self.assertEqual(result.shouldStop, True) 67 68 # "Called when the test case test is about to be run. The default 69 # implementation simply increments the instance's testsRun counter." 70 def test_startTest(self): 71 class Foo(unittest.TestCase): 72 def test_1(self): 73 pass 74 75 test = Foo('test_1') 76 77 result = unittest.TestResult() 78 79 result.startTest(test) 80 81 self.assertTrue(result.wasSuccessful()) 82 self.assertEqual(len(result.errors), 0) 83 self.assertEqual(len(result.failures), 0) 84 self.assertEqual(result.testsRun, 1) 85 self.assertEqual(result.shouldStop, False) 86 87 result.stopTest(test) 88 89 # "Called after the test case test has been executed, regardless of 90 # the outcome. The default implementation does nothing." 91 def test_stopTest(self): 92 class Foo(unittest.TestCase): 93 def test_1(self): 94 pass 95 96 test = Foo('test_1') 97 98 result = unittest.TestResult() 99 100 result.startTest(test) 101 102 self.assertTrue(result.wasSuccessful()) 103 self.assertEqual(len(result.errors), 0) 104 self.assertEqual(len(result.failures), 0) 105 self.assertEqual(result.testsRun, 1) 106 self.assertEqual(result.shouldStop, False) 107 108 result.stopTest(test) 109 110 # Same tests as above; make sure nothing has changed 111 self.assertTrue(result.wasSuccessful()) 112 self.assertEqual(len(result.errors), 0) 113 self.assertEqual(len(result.failures), 0) 114 self.assertEqual(result.testsRun, 1) 115 self.assertEqual(result.shouldStop, False) 116 117 # "Called before and after tests are run. The default implementation does nothing." 118 def test_startTestRun_stopTestRun(self): 119 result = unittest.TestResult() 120 result.startTestRun() 121 result.stopTestRun() 122 123 # "addSuccess(test)" 124 # ... 125 # "Called when the test case test succeeds" 126 # ... 127 # "wasSuccessful() - Returns True if all tests run so far have passed, 128 # otherwise returns False" 129 # ... 130 # "testsRun - The total number of tests run so far." 131 # ... 132 # "errors - A list containing 2-tuples of TestCase instances and 133 # formatted tracebacks. Each tuple represents a test which raised an 134 # unexpected exception. Contains formatted 135 # tracebacks instead of sys.exc_info() results." 136 # ... 137 # "failures - A list containing 2-tuples of TestCase instances and 138 # formatted tracebacks. Each tuple represents a test where a failure was 139 # explicitly signalled using the TestCase.fail*() or TestCase.assert*() 140 # methods. Contains formatted tracebacks instead 141 # of sys.exc_info() results." 142 def test_addSuccess(self): 143 class Foo(unittest.TestCase): 144 def test_1(self): 145 pass 146 147 test = Foo('test_1') 148 149 result = unittest.TestResult() 150 151 result.startTest(test) 152 result.addSuccess(test) 153 result.stopTest(test) 154 155 self.assertTrue(result.wasSuccessful()) 156 self.assertEqual(len(result.errors), 0) 157 self.assertEqual(len(result.failures), 0) 158 self.assertEqual(result.testsRun, 1) 159 self.assertEqual(result.shouldStop, False) 160 161 # "addFailure(test, err)" 162 # ... 163 # "Called when the test case test signals a failure. err is a tuple of 164 # the form returned by sys.exc_info(): (type, value, traceback)" 165 # ... 166 # "wasSuccessful() - Returns True if all tests run so far have passed, 167 # otherwise returns False" 168 # ... 169 # "testsRun - The total number of tests run so far." 170 # ... 171 # "errors - A list containing 2-tuples of TestCase instances and 172 # formatted tracebacks. Each tuple represents a test which raised an 173 # unexpected exception. Contains formatted 174 # tracebacks instead of sys.exc_info() results." 175 # ... 176 # "failures - A list containing 2-tuples of TestCase instances and 177 # formatted tracebacks. Each tuple represents a test where a failure was 178 # explicitly signalled using the TestCase.fail*() or TestCase.assert*() 179 # methods. Contains formatted tracebacks instead 180 # of sys.exc_info() results." 181 def test_addFailure(self): 182 class Foo(unittest.TestCase): 183 def test_1(self): 184 pass 185 186 test = Foo('test_1') 187 try: 188 test.fail("foo") 189 except: 190 exc_info_tuple = sys.exc_info() 191 192 result = unittest.TestResult() 193 194 result.startTest(test) 195 result.addFailure(test, exc_info_tuple) 196 result.stopTest(test) 197 198 self.assertFalse(result.wasSuccessful()) 199 self.assertEqual(len(result.errors), 0) 200 self.assertEqual(len(result.failures), 1) 201 self.assertEqual(result.testsRun, 1) 202 self.assertEqual(result.shouldStop, False) 203 204 test_case, formatted_exc = result.failures[0] 205 self.assertIs(test_case, test) 206 self.assertIsInstance(formatted_exc, str) 207 208 def test_addFailure_filter_traceback_frames(self): 209 class Foo(unittest.TestCase): 210 def test_1(self): 211 pass 212 213 test = Foo('test_1') 214 def get_exc_info(): 215 try: 216 test.fail("foo") 217 except: 218 return sys.exc_info() 219 220 exc_info_tuple = get_exc_info() 221 222 full_exc = traceback.format_exception(*exc_info_tuple) 223 224 result = unittest.TestResult() 225 result.startTest(test) 226 result.addFailure(test, exc_info_tuple) 227 result.stopTest(test) 228 229 formatted_exc = result.failures[0][1] 230 dropped = [l for l in full_exc if l not in formatted_exc] 231 self.assertEqual(len(dropped), 1) 232 self.assertIn("raise self.failureException(msg)", dropped[0]) 233 234 def test_addFailure_filter_traceback_frames_context(self): 235 class Foo(unittest.TestCase): 236 def test_1(self): 237 pass 238 239 test = Foo('test_1') 240 def get_exc_info(): 241 try: 242 try: 243 test.fail("foo") 244 except: 245 raise ValueError(42) 246 except: 247 return sys.exc_info() 248 249 exc_info_tuple = get_exc_info() 250 251 full_exc = traceback.format_exception(*exc_info_tuple) 252 253 result = unittest.TestResult() 254 result.startTest(test) 255 result.addFailure(test, exc_info_tuple) 256 result.stopTest(test) 257 258 formatted_exc = result.failures[0][1] 259 dropped = [l for l in full_exc if l not in formatted_exc] 260 self.assertEqual(len(dropped), 1) 261 self.assertIn("raise self.failureException(msg)", dropped[0]) 262 263 def test_addFailure_filter_traceback_frames_chained_exception_self_loop(self): 264 class Foo(unittest.TestCase): 265 def test_1(self): 266 pass 267 268 def get_exc_info(): 269 try: 270 loop = Exception("Loop") 271 loop.__cause__ = loop 272 loop.__context__ = loop 273 raise loop 274 except: 275 return sys.exc_info() 276 277 exc_info_tuple = get_exc_info() 278 279 test = Foo('test_1') 280 result = unittest.TestResult() 281 result.startTest(test) 282 result.addFailure(test, exc_info_tuple) 283 result.stopTest(test) 284 285 formatted_exc = result.failures[0][1] 286 self.assertEqual(formatted_exc.count("Exception: Loop\n"), 1) 287 288 def test_addFailure_filter_traceback_frames_chained_exception_cycle(self): 289 class Foo(unittest.TestCase): 290 def test_1(self): 291 pass 292 293 def get_exc_info(): 294 try: 295 # Create two directionally opposed cycles 296 # __cause__ in one direction, __context__ in the other 297 A, B, C = Exception("A"), Exception("B"), Exception("C") 298 edges = [(C, B), (B, A), (A, C)] 299 for ex1, ex2 in edges: 300 ex1.__cause__ = ex2 301 ex2.__context__ = ex1 302 raise C 303 except: 304 return sys.exc_info() 305 306 exc_info_tuple = get_exc_info() 307 308 test = Foo('test_1') 309 result = unittest.TestResult() 310 result.startTest(test) 311 result.addFailure(test, exc_info_tuple) 312 result.stopTest(test) 313 314 formatted_exc = result.failures[0][1] 315 self.assertEqual(formatted_exc.count("Exception: A\n"), 1) 316 self.assertEqual(formatted_exc.count("Exception: B\n"), 1) 317 self.assertEqual(formatted_exc.count("Exception: C\n"), 1) 318 319 # "addError(test, err)" 320 # ... 321 # "Called when the test case test raises an unexpected exception err 322 # is a tuple of the form returned by sys.exc_info(): 323 # (type, value, traceback)" 324 # ... 325 # "wasSuccessful() - Returns True if all tests run so far have passed, 326 # otherwise returns False" 327 # ... 328 # "testsRun - The total number of tests run so far." 329 # ... 330 # "errors - A list containing 2-tuples of TestCase instances and 331 # formatted tracebacks. Each tuple represents a test which raised an 332 # unexpected exception. Contains formatted 333 # tracebacks instead of sys.exc_info() results." 334 # ... 335 # "failures - A list containing 2-tuples of TestCase instances and 336 # formatted tracebacks. Each tuple represents a test where a failure was 337 # explicitly signalled using the TestCase.fail*() or TestCase.assert*() 338 # methods. Contains formatted tracebacks instead 339 # of sys.exc_info() results." 340 def test_addError(self): 341 class Foo(unittest.TestCase): 342 def test_1(self): 343 pass 344 345 test = Foo('test_1') 346 try: 347 raise TypeError() 348 except: 349 exc_info_tuple = sys.exc_info() 350 351 result = unittest.TestResult() 352 353 result.startTest(test) 354 result.addError(test, exc_info_tuple) 355 result.stopTest(test) 356 357 self.assertFalse(result.wasSuccessful()) 358 self.assertEqual(len(result.errors), 1) 359 self.assertEqual(len(result.failures), 0) 360 self.assertEqual(result.testsRun, 1) 361 self.assertEqual(result.shouldStop, False) 362 363 test_case, formatted_exc = result.errors[0] 364 self.assertIs(test_case, test) 365 self.assertIsInstance(formatted_exc, str) 366 367 def test_addError_locals(self): 368 class Foo(unittest.TestCase): 369 def test_1(self): 370 1/0 371 372 test = Foo('test_1') 373 result = unittest.TestResult() 374 result.tb_locals = True 375 376 unittest.result.traceback = MockTraceback 377 self.addCleanup(restore_traceback) 378 result.startTestRun() 379 test.run(result) 380 result.stopTestRun() 381 382 self.assertEqual(len(result.errors), 1) 383 test_case, formatted_exc = result.errors[0] 384 self.assertEqual('A tracebacklocals', formatted_exc) 385 386 def test_addSubTest(self): 387 class Foo(unittest.TestCase): 388 def test_1(self): 389 nonlocal subtest 390 with self.subTest(foo=1): 391 subtest = self._subtest 392 try: 393 1/0 394 except ZeroDivisionError: 395 exc_info_tuple = sys.exc_info() 396 # Register an error by hand (to check the API) 397 result.addSubTest(test, subtest, exc_info_tuple) 398 # Now trigger a failure 399 self.fail("some recognizable failure") 400 401 subtest = None 402 test = Foo('test_1') 403 result = unittest.TestResult() 404 405 test.run(result) 406 407 self.assertFalse(result.wasSuccessful()) 408 self.assertEqual(len(result.errors), 1) 409 self.assertEqual(len(result.failures), 1) 410 self.assertEqual(result.testsRun, 1) 411 self.assertEqual(result.shouldStop, False) 412 413 test_case, formatted_exc = result.errors[0] 414 self.assertIs(test_case, subtest) 415 self.assertIn("ZeroDivisionError", formatted_exc) 416 test_case, formatted_exc = result.failures[0] 417 self.assertIs(test_case, subtest) 418 self.assertIn("some recognizable failure", formatted_exc) 419 420 def testStackFrameTrimming(self): 421 class Frame(object): 422 class tb_frame(object): 423 f_globals = {} 424 result = unittest.TestResult() 425 self.assertFalse(result._is_relevant_tb_level(Frame)) 426 427 Frame.tb_frame.f_globals['__unittest'] = True 428 self.assertTrue(result._is_relevant_tb_level(Frame)) 429 430 def testFailFast(self): 431 result = unittest.TestResult() 432 result._exc_info_to_string = lambda *_: '' 433 result.failfast = True 434 result.addError(None, None) 435 self.assertTrue(result.shouldStop) 436 437 result = unittest.TestResult() 438 result._exc_info_to_string = lambda *_: '' 439 result.failfast = True 440 result.addFailure(None, None) 441 self.assertTrue(result.shouldStop) 442 443 result = unittest.TestResult() 444 result._exc_info_to_string = lambda *_: '' 445 result.failfast = True 446 result.addUnexpectedSuccess(None) 447 self.assertTrue(result.shouldStop) 448 449 def testFailFastSetByRunner(self): 450 stream = BufferedWriter() 451 runner = unittest.TextTestRunner(stream=stream, failfast=True) 452 def test(result): 453 result.testsRun += 1 454 self.assertTrue(result.failfast) 455 result = runner.run(test) 456 stream.flush() 457 self.assertTrue(stream.getvalue().endswith('\n\nOK\n')) 458 459 460class Test_TextTestResult(unittest.TestCase): 461 maxDiff = None 462 463 def testGetDescriptionWithoutDocstring(self): 464 result = unittest.TextTestResult(None, True, 1) 465 self.assertEqual( 466 result.getDescription(self), 467 'testGetDescriptionWithoutDocstring (' + __name__ + 468 '.Test_TextTestResult.testGetDescriptionWithoutDocstring)') 469 470 def testGetSubTestDescriptionWithoutDocstring(self): 471 with self.subTest(foo=1, bar=2): 472 result = unittest.TextTestResult(None, True, 1) 473 self.assertEqual( 474 result.getDescription(self._subtest), 475 'testGetSubTestDescriptionWithoutDocstring (' + __name__ + 476 '.Test_TextTestResult.testGetSubTestDescriptionWithoutDocstring) (foo=1, bar=2)') 477 478 with self.subTest('some message'): 479 result = unittest.TextTestResult(None, True, 1) 480 self.assertEqual( 481 result.getDescription(self._subtest), 482 'testGetSubTestDescriptionWithoutDocstring (' + __name__ + 483 '.Test_TextTestResult.testGetSubTestDescriptionWithoutDocstring) [some message]') 484 485 def testGetSubTestDescriptionWithoutDocstringAndParams(self): 486 with self.subTest(): 487 result = unittest.TextTestResult(None, True, 1) 488 self.assertEqual( 489 result.getDescription(self._subtest), 490 'testGetSubTestDescriptionWithoutDocstringAndParams ' 491 '(' + __name__ + '.Test_TextTestResult.testGetSubTestDescriptionWithoutDocstringAndParams) ' 492 '(<subtest>)') 493 494 def testGetSubTestDescriptionForFalseValues(self): 495 expected = 'testGetSubTestDescriptionForFalseValues (%s.Test_TextTestResult.testGetSubTestDescriptionForFalseValues) [%s]' 496 result = unittest.TextTestResult(None, True, 1) 497 for arg in [0, None, []]: 498 with self.subTest(arg): 499 self.assertEqual( 500 result.getDescription(self._subtest), 501 expected % (__name__, arg) 502 ) 503 504 def testGetNestedSubTestDescriptionWithoutDocstring(self): 505 with self.subTest(foo=1): 506 with self.subTest(baz=2, bar=3): 507 result = unittest.TextTestResult(None, True, 1) 508 self.assertEqual( 509 result.getDescription(self._subtest), 510 'testGetNestedSubTestDescriptionWithoutDocstring ' 511 '(' + __name__ + '.Test_TextTestResult.testGetNestedSubTestDescriptionWithoutDocstring) ' 512 '(baz=2, bar=3, foo=1)') 513 514 def testGetDuplicatedNestedSubTestDescriptionWithoutDocstring(self): 515 with self.subTest(foo=1, bar=2): 516 with self.subTest(baz=3, bar=4): 517 result = unittest.TextTestResult(None, True, 1) 518 self.assertEqual( 519 result.getDescription(self._subtest), 520 'testGetDuplicatedNestedSubTestDescriptionWithoutDocstring ' 521 '(' + __name__ + '.Test_TextTestResult.testGetDuplicatedNestedSubTestDescriptionWithoutDocstring) (baz=3, bar=4, foo=1)') 522 523 @unittest.skipIf(sys.flags.optimize >= 2, 524 "Docstrings are omitted with -O2 and above") 525 def testGetDescriptionWithOneLineDocstring(self): 526 """Tests getDescription() for a method with a docstring.""" 527 result = unittest.TextTestResult(None, True, 1) 528 self.assertEqual( 529 result.getDescription(self), 530 ('testGetDescriptionWithOneLineDocstring ' 531 '(' + __name__ + '.Test_TextTestResult.testGetDescriptionWithOneLineDocstring)\n' 532 'Tests getDescription() for a method with a docstring.')) 533 534 @unittest.skipIf(sys.flags.optimize >= 2, 535 "Docstrings are omitted with -O2 and above") 536 def testGetSubTestDescriptionWithOneLineDocstring(self): 537 """Tests getDescription() for a method with a docstring.""" 538 result = unittest.TextTestResult(None, True, 1) 539 with self.subTest(foo=1, bar=2): 540 self.assertEqual( 541 result.getDescription(self._subtest), 542 ('testGetSubTestDescriptionWithOneLineDocstring ' 543 '(' + __name__ + '.Test_TextTestResult.testGetSubTestDescriptionWithOneLineDocstring) ' 544 '(foo=1, bar=2)\n' 545 546 'Tests getDescription() for a method with a docstring.')) 547 548 @unittest.skipIf(sys.flags.optimize >= 2, 549 "Docstrings are omitted with -O2 and above") 550 def testGetDescriptionWithMultiLineDocstring(self): 551 """Tests getDescription() for a method with a longer docstring. 552 The second line of the docstring. 553 """ 554 result = unittest.TextTestResult(None, True, 1) 555 self.assertEqual( 556 result.getDescription(self), 557 ('testGetDescriptionWithMultiLineDocstring ' 558 '(' + __name__ + '.Test_TextTestResult.testGetDescriptionWithMultiLineDocstring)\n' 559 'Tests getDescription() for a method with a longer ' 560 'docstring.')) 561 562 @unittest.skipIf(sys.flags.optimize >= 2, 563 "Docstrings are omitted with -O2 and above") 564 def testGetSubTestDescriptionWithMultiLineDocstring(self): 565 """Tests getDescription() for a method with a longer docstring. 566 The second line of the docstring. 567 """ 568 result = unittest.TextTestResult(None, True, 1) 569 with self.subTest(foo=1, bar=2): 570 self.assertEqual( 571 result.getDescription(self._subtest), 572 ('testGetSubTestDescriptionWithMultiLineDocstring ' 573 '(' + __name__ + '.Test_TextTestResult.testGetSubTestDescriptionWithMultiLineDocstring) ' 574 '(foo=1, bar=2)\n' 575 'Tests getDescription() for a method with a longer ' 576 'docstring.')) 577 578 class Test(unittest.TestCase): 579 def testSuccess(self): 580 pass 581 def testSkip(self): 582 self.skipTest('skip') 583 def testFail(self): 584 self.fail('fail') 585 def testError(self): 586 raise Exception('error') 587 @unittest.expectedFailure 588 def testExpectedFailure(self): 589 self.fail('fail') 590 @unittest.expectedFailure 591 def testUnexpectedSuccess(self): 592 pass 593 def testSubTestSuccess(self): 594 with self.subTest('one', a=1): 595 pass 596 with self.subTest('two', b=2): 597 pass 598 def testSubTestMixed(self): 599 with self.subTest('success', a=1): 600 pass 601 with self.subTest('skip', b=2): 602 self.skipTest('skip') 603 with self.subTest('fail', c=3): 604 self.fail('fail') 605 with self.subTest('error', d=4): 606 raise Exception('error') 607 608 tearDownError = None 609 def tearDown(self): 610 if self.tearDownError is not None: 611 raise self.tearDownError 612 613 def _run_test(self, test_name, verbosity, tearDownError=None): 614 stream = BufferedWriter() 615 stream = unittest.runner._WritelnDecorator(stream) 616 result = unittest.TextTestResult(stream, True, verbosity) 617 test = self.Test(test_name) 618 test.tearDownError = tearDownError 619 test.run(result) 620 return stream.getvalue() 621 622 def testDotsOutput(self): 623 self.assertEqual(self._run_test('testSuccess', 1), '.') 624 self.assertEqual(self._run_test('testSkip', 1), 's') 625 self.assertEqual(self._run_test('testFail', 1), 'F') 626 self.assertEqual(self._run_test('testError', 1), 'E') 627 self.assertEqual(self._run_test('testExpectedFailure', 1), 'x') 628 self.assertEqual(self._run_test('testUnexpectedSuccess', 1), 'u') 629 630 def testLongOutput(self): 631 classname = f'{__name__}.{self.Test.__qualname__}' 632 self.assertEqual(self._run_test('testSuccess', 2), 633 f'testSuccess ({classname}.testSuccess) ... ok\n') 634 self.assertEqual(self._run_test('testSkip', 2), 635 f"testSkip ({classname}.testSkip) ... skipped 'skip'\n") 636 self.assertEqual(self._run_test('testFail', 2), 637 f'testFail ({classname}.testFail) ... FAIL\n') 638 self.assertEqual(self._run_test('testError', 2), 639 f'testError ({classname}.testError) ... ERROR\n') 640 self.assertEqual(self._run_test('testExpectedFailure', 2), 641 f'testExpectedFailure ({classname}.testExpectedFailure) ... expected failure\n') 642 self.assertEqual(self._run_test('testUnexpectedSuccess', 2), 643 f'testUnexpectedSuccess ({classname}.testUnexpectedSuccess) ... unexpected success\n') 644 645 def testDotsOutputSubTestSuccess(self): 646 self.assertEqual(self._run_test('testSubTestSuccess', 1), '.') 647 648 def testLongOutputSubTestSuccess(self): 649 classname = f'{__name__}.{self.Test.__qualname__}' 650 self.assertEqual(self._run_test('testSubTestSuccess', 2), 651 f'testSubTestSuccess ({classname}.testSubTestSuccess) ... ok\n') 652 653 def testDotsOutputSubTestMixed(self): 654 self.assertEqual(self._run_test('testSubTestMixed', 1), 'sFE') 655 656 def testLongOutputSubTestMixed(self): 657 classname = f'{__name__}.{self.Test.__qualname__}' 658 self.assertEqual(self._run_test('testSubTestMixed', 2), 659 f'testSubTestMixed ({classname}.testSubTestMixed) ... \n' 660 f" testSubTestMixed ({classname}.testSubTestMixed) [skip] (b=2) ... skipped 'skip'\n" 661 f' testSubTestMixed ({classname}.testSubTestMixed) [fail] (c=3) ... FAIL\n' 662 f' testSubTestMixed ({classname}.testSubTestMixed) [error] (d=4) ... ERROR\n') 663 664 def testDotsOutputTearDownFail(self): 665 out = self._run_test('testSuccess', 1, AssertionError('fail')) 666 self.assertEqual(out, 'F') 667 out = self._run_test('testError', 1, AssertionError('fail')) 668 self.assertEqual(out, 'EF') 669 out = self._run_test('testFail', 1, Exception('error')) 670 self.assertEqual(out, 'FE') 671 out = self._run_test('testSkip', 1, AssertionError('fail')) 672 self.assertEqual(out, 'sF') 673 674 def testLongOutputTearDownFail(self): 675 classname = f'{__name__}.{self.Test.__qualname__}' 676 out = self._run_test('testSuccess', 2, AssertionError('fail')) 677 self.assertEqual(out, 678 f'testSuccess ({classname}.testSuccess) ... FAIL\n') 679 out = self._run_test('testError', 2, AssertionError('fail')) 680 self.assertEqual(out, 681 f'testError ({classname}.testError) ... ERROR\n' 682 f'testError ({classname}.testError) ... FAIL\n') 683 out = self._run_test('testFail', 2, Exception('error')) 684 self.assertEqual(out, 685 f'testFail ({classname}.testFail) ... FAIL\n' 686 f'testFail ({classname}.testFail) ... ERROR\n') 687 out = self._run_test('testSkip', 2, AssertionError('fail')) 688 self.assertEqual(out, 689 f"testSkip ({classname}.testSkip) ... skipped 'skip'\n" 690 f'testSkip ({classname}.testSkip) ... FAIL\n') 691 692 693classDict = dict(unittest.TestResult.__dict__) 694for m in ('addSkip', 'addExpectedFailure', 'addUnexpectedSuccess', 695 '__init__'): 696 del classDict[m] 697 698def __init__(self, stream=None, descriptions=None, verbosity=None): 699 self.failures = [] 700 self.errors = [] 701 self.testsRun = 0 702 self.shouldStop = False 703 self.buffer = False 704 self.tb_locals = False 705 706classDict['__init__'] = __init__ 707OldResult = type('OldResult', (object,), classDict) 708 709class Test_OldTestResult(unittest.TestCase): 710 711 def assertOldResultWarning(self, test, failures): 712 with warnings_helper.check_warnings( 713 ("TestResult has no add.+ method,", RuntimeWarning)): 714 result = OldResult() 715 test.run(result) 716 self.assertEqual(len(result.failures), failures) 717 718 def testOldTestResult(self): 719 class Test(unittest.TestCase): 720 def testSkip(self): 721 self.skipTest('foobar') 722 @unittest.expectedFailure 723 def testExpectedFail(self): 724 raise TypeError 725 @unittest.expectedFailure 726 def testUnexpectedSuccess(self): 727 pass 728 729 for test_name, should_pass in (('testSkip', True), 730 ('testExpectedFail', True), 731 ('testUnexpectedSuccess', False)): 732 test = Test(test_name) 733 self.assertOldResultWarning(test, int(not should_pass)) 734 735 def testOldTestTesultSetup(self): 736 class Test(unittest.TestCase): 737 def setUp(self): 738 self.skipTest('no reason') 739 def testFoo(self): 740 pass 741 self.assertOldResultWarning(Test('testFoo'), 0) 742 743 def testOldTestResultClass(self): 744 @unittest.skip('no reason') 745 class Test(unittest.TestCase): 746 def testFoo(self): 747 pass 748 self.assertOldResultWarning(Test('testFoo'), 0) 749 750 def testOldResultWithRunner(self): 751 class Test(unittest.TestCase): 752 def testFoo(self): 753 pass 754 runner = unittest.TextTestRunner(resultclass=OldResult, 755 stream=io.StringIO()) 756 # This will raise an exception if TextTestRunner can't handle old 757 # test result objects 758 runner.run(Test('testFoo')) 759 760 761class TestOutputBuffering(unittest.TestCase): 762 763 def setUp(self): 764 self._real_out = sys.stdout 765 self._real_err = sys.stderr 766 767 def tearDown(self): 768 sys.stdout = self._real_out 769 sys.stderr = self._real_err 770 771 def testBufferOutputOff(self): 772 real_out = self._real_out 773 real_err = self._real_err 774 775 result = unittest.TestResult() 776 self.assertFalse(result.buffer) 777 778 self.assertIs(real_out, sys.stdout) 779 self.assertIs(real_err, sys.stderr) 780 781 result.startTest(self) 782 783 self.assertIs(real_out, sys.stdout) 784 self.assertIs(real_err, sys.stderr) 785 786 def testBufferOutputStartTestAddSuccess(self): 787 real_out = self._real_out 788 real_err = self._real_err 789 790 result = unittest.TestResult() 791 self.assertFalse(result.buffer) 792 793 result.buffer = True 794 795 self.assertIs(real_out, sys.stdout) 796 self.assertIs(real_err, sys.stderr) 797 798 result.startTest(self) 799 800 self.assertIsNot(real_out, sys.stdout) 801 self.assertIsNot(real_err, sys.stderr) 802 self.assertIsInstance(sys.stdout, io.StringIO) 803 self.assertIsInstance(sys.stderr, io.StringIO) 804 self.assertIsNot(sys.stdout, sys.stderr) 805 806 out_stream = sys.stdout 807 err_stream = sys.stderr 808 809 result._original_stdout = io.StringIO() 810 result._original_stderr = io.StringIO() 811 812 print('foo') 813 print('bar', file=sys.stderr) 814 815 self.assertEqual(out_stream.getvalue(), 'foo\n') 816 self.assertEqual(err_stream.getvalue(), 'bar\n') 817 818 self.assertEqual(result._original_stdout.getvalue(), '') 819 self.assertEqual(result._original_stderr.getvalue(), '') 820 821 result.addSuccess(self) 822 result.stopTest(self) 823 824 self.assertIs(sys.stdout, result._original_stdout) 825 self.assertIs(sys.stderr, result._original_stderr) 826 827 self.assertEqual(result._original_stdout.getvalue(), '') 828 self.assertEqual(result._original_stderr.getvalue(), '') 829 830 self.assertEqual(out_stream.getvalue(), '') 831 self.assertEqual(err_stream.getvalue(), '') 832 833 834 def getStartedResult(self): 835 result = unittest.TestResult() 836 result.buffer = True 837 result.startTest(self) 838 return result 839 840 def testBufferOutputAddErrorOrFailure(self): 841 unittest.result.traceback = MockTraceback 842 self.addCleanup(restore_traceback) 843 844 for message_attr, add_attr, include_error in [ 845 ('errors', 'addError', True), 846 ('failures', 'addFailure', False), 847 ('errors', 'addError', True), 848 ('failures', 'addFailure', False) 849 ]: 850 result = self.getStartedResult() 851 buffered_out = sys.stdout 852 buffered_err = sys.stderr 853 result._original_stdout = io.StringIO() 854 result._original_stderr = io.StringIO() 855 856 print('foo', file=sys.stdout) 857 if include_error: 858 print('bar', file=sys.stderr) 859 860 861 addFunction = getattr(result, add_attr) 862 addFunction(self, (None, None, None)) 863 result.stopTest(self) 864 865 result_list = getattr(result, message_attr) 866 self.assertEqual(len(result_list), 1) 867 868 test, message = result_list[0] 869 expectedOutMessage = textwrap.dedent(""" 870 Stdout: 871 foo 872 """) 873 expectedErrMessage = '' 874 if include_error: 875 expectedErrMessage = textwrap.dedent(""" 876 Stderr: 877 bar 878 """) 879 880 expectedFullMessage = 'A traceback%s%s' % (expectedOutMessage, expectedErrMessage) 881 882 self.assertIs(test, self) 883 self.assertEqual(result._original_stdout.getvalue(), expectedOutMessage) 884 self.assertEqual(result._original_stderr.getvalue(), expectedErrMessage) 885 self.assertMultiLineEqual(message, expectedFullMessage) 886 887 def testBufferSetUp(self): 888 with captured_stdout() as stdout: 889 result = unittest.TestResult() 890 result.buffer = True 891 892 class Foo(unittest.TestCase): 893 def setUp(self): 894 print('set up') 895 1/0 896 def test_foo(self): 897 pass 898 suite = unittest.TestSuite([Foo('test_foo')]) 899 suite(result) 900 expected_out = '\nStdout:\nset up\n' 901 self.assertEqual(stdout.getvalue(), expected_out) 902 self.assertEqual(len(result.errors), 1) 903 description = f'test_foo ({strclass(Foo)}.test_foo)' 904 test_case, formatted_exc = result.errors[0] 905 self.assertEqual(str(test_case), description) 906 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 907 self.assertIn(expected_out, formatted_exc) 908 909 def testBufferTearDown(self): 910 with captured_stdout() as stdout: 911 result = unittest.TestResult() 912 result.buffer = True 913 914 class Foo(unittest.TestCase): 915 def tearDown(self): 916 print('tear down') 917 1/0 918 def test_foo(self): 919 pass 920 suite = unittest.TestSuite([Foo('test_foo')]) 921 suite(result) 922 expected_out = '\nStdout:\ntear down\n' 923 self.assertEqual(stdout.getvalue(), expected_out) 924 self.assertEqual(len(result.errors), 1) 925 description = f'test_foo ({strclass(Foo)}.test_foo)' 926 test_case, formatted_exc = result.errors[0] 927 self.assertEqual(str(test_case), description) 928 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 929 self.assertIn(expected_out, formatted_exc) 930 931 def testBufferDoCleanups(self): 932 with captured_stdout() as stdout: 933 result = unittest.TestResult() 934 result.buffer = True 935 936 class Foo(unittest.TestCase): 937 def setUp(self): 938 print('set up') 939 self.addCleanup(bad_cleanup1) 940 self.addCleanup(bad_cleanup2) 941 def test_foo(self): 942 pass 943 suite = unittest.TestSuite([Foo('test_foo')]) 944 suite(result) 945 expected_out = '\nStdout:\nset up\ndo cleanup2\ndo cleanup1\n' 946 self.assertEqual(stdout.getvalue(), expected_out) 947 self.assertEqual(len(result.errors), 2) 948 description = f'test_foo ({strclass(Foo)}.test_foo)' 949 test_case, formatted_exc = result.errors[0] 950 self.assertEqual(str(test_case), description) 951 self.assertIn('ValueError: bad cleanup2', formatted_exc) 952 self.assertNotIn('TypeError', formatted_exc) 953 self.assertIn('\nStdout:\nset up\ndo cleanup2\n', formatted_exc) 954 self.assertNotIn('\ndo cleanup1\n', formatted_exc) 955 test_case, formatted_exc = result.errors[1] 956 self.assertEqual(str(test_case), description) 957 self.assertIn('TypeError: bad cleanup1', formatted_exc) 958 self.assertNotIn('ValueError', formatted_exc) 959 self.assertIn(expected_out, formatted_exc) 960 961 def testBufferSetUp_DoCleanups(self): 962 with captured_stdout() as stdout: 963 result = unittest.TestResult() 964 result.buffer = True 965 966 class Foo(unittest.TestCase): 967 def setUp(self): 968 print('set up') 969 self.addCleanup(bad_cleanup1) 970 self.addCleanup(bad_cleanup2) 971 1/0 972 def test_foo(self): 973 pass 974 suite = unittest.TestSuite([Foo('test_foo')]) 975 suite(result) 976 expected_out = '\nStdout:\nset up\ndo cleanup2\ndo cleanup1\n' 977 self.assertEqual(stdout.getvalue(), expected_out) 978 self.assertEqual(len(result.errors), 3) 979 description = f'test_foo ({strclass(Foo)}.test_foo)' 980 test_case, formatted_exc = result.errors[0] 981 self.assertEqual(str(test_case), description) 982 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 983 self.assertNotIn('ValueError', formatted_exc) 984 self.assertNotIn('TypeError', formatted_exc) 985 self.assertIn('\nStdout:\nset up\n', formatted_exc) 986 self.assertNotIn('\ndo cleanup2\n', formatted_exc) 987 self.assertNotIn('\ndo cleanup1\n', formatted_exc) 988 test_case, formatted_exc = result.errors[1] 989 self.assertEqual(str(test_case), description) 990 self.assertIn('ValueError: bad cleanup2', formatted_exc) 991 self.assertNotIn('ZeroDivisionError', formatted_exc) 992 self.assertNotIn('TypeError', formatted_exc) 993 self.assertIn('\nStdout:\nset up\ndo cleanup2\n', formatted_exc) 994 self.assertNotIn('\ndo cleanup1\n', formatted_exc) 995 test_case, formatted_exc = result.errors[2] 996 self.assertEqual(str(test_case), description) 997 self.assertIn('TypeError: bad cleanup1', formatted_exc) 998 self.assertNotIn('ZeroDivisionError', formatted_exc) 999 self.assertNotIn('ValueError', formatted_exc) 1000 self.assertIn(expected_out, formatted_exc) 1001 1002 def testBufferTearDown_DoCleanups(self): 1003 with captured_stdout() as stdout: 1004 result = unittest.TestResult() 1005 result.buffer = True 1006 1007 class Foo(unittest.TestCase): 1008 def setUp(self): 1009 print('set up') 1010 self.addCleanup(bad_cleanup1) 1011 self.addCleanup(bad_cleanup2) 1012 def tearDown(self): 1013 print('tear down') 1014 1/0 1015 def test_foo(self): 1016 pass 1017 suite = unittest.TestSuite([Foo('test_foo')]) 1018 suite(result) 1019 expected_out = '\nStdout:\nset up\ntear down\ndo cleanup2\ndo cleanup1\n' 1020 self.assertEqual(stdout.getvalue(), expected_out) 1021 self.assertEqual(len(result.errors), 3) 1022 description = f'test_foo ({strclass(Foo)}.test_foo)' 1023 test_case, formatted_exc = result.errors[0] 1024 self.assertEqual(str(test_case), description) 1025 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 1026 self.assertNotIn('ValueError', formatted_exc) 1027 self.assertNotIn('TypeError', formatted_exc) 1028 self.assertIn('\nStdout:\nset up\ntear down\n', formatted_exc) 1029 self.assertNotIn('\ndo cleanup2\n', formatted_exc) 1030 self.assertNotIn('\ndo cleanup1\n', formatted_exc) 1031 test_case, formatted_exc = result.errors[1] 1032 self.assertEqual(str(test_case), description) 1033 self.assertIn('ValueError: bad cleanup2', formatted_exc) 1034 self.assertNotIn('ZeroDivisionError', formatted_exc) 1035 self.assertNotIn('TypeError', formatted_exc) 1036 self.assertIn('\nStdout:\nset up\ntear down\ndo cleanup2\n', formatted_exc) 1037 self.assertNotIn('\ndo cleanup1\n', formatted_exc) 1038 test_case, formatted_exc = result.errors[2] 1039 self.assertEqual(str(test_case), description) 1040 self.assertIn('TypeError: bad cleanup1', formatted_exc) 1041 self.assertNotIn('ZeroDivisionError', formatted_exc) 1042 self.assertNotIn('ValueError', formatted_exc) 1043 self.assertIn(expected_out, formatted_exc) 1044 1045 def testBufferSetupClass(self): 1046 with captured_stdout() as stdout: 1047 result = unittest.TestResult() 1048 result.buffer = True 1049 1050 class Foo(unittest.TestCase): 1051 @classmethod 1052 def setUpClass(cls): 1053 print('set up class') 1054 1/0 1055 def test_foo(self): 1056 pass 1057 suite = unittest.TestSuite([Foo('test_foo')]) 1058 suite(result) 1059 expected_out = '\nStdout:\nset up class\n' 1060 self.assertEqual(stdout.getvalue(), expected_out) 1061 self.assertEqual(len(result.errors), 1) 1062 description = f'setUpClass ({strclass(Foo)})' 1063 test_case, formatted_exc = result.errors[0] 1064 self.assertEqual(test_case.description, description) 1065 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 1066 self.assertIn(expected_out, formatted_exc) 1067 1068 def testBufferTearDownClass(self): 1069 with captured_stdout() as stdout: 1070 result = unittest.TestResult() 1071 result.buffer = True 1072 1073 class Foo(unittest.TestCase): 1074 @classmethod 1075 def tearDownClass(cls): 1076 print('tear down class') 1077 1/0 1078 def test_foo(self): 1079 pass 1080 suite = unittest.TestSuite([Foo('test_foo')]) 1081 suite(result) 1082 expected_out = '\nStdout:\ntear down class\n' 1083 self.assertEqual(stdout.getvalue(), expected_out) 1084 self.assertEqual(len(result.errors), 1) 1085 description = f'tearDownClass ({strclass(Foo)})' 1086 test_case, formatted_exc = result.errors[0] 1087 self.assertEqual(test_case.description, description) 1088 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 1089 self.assertIn(expected_out, formatted_exc) 1090 1091 def testBufferDoClassCleanups(self): 1092 with captured_stdout() as stdout: 1093 result = unittest.TestResult() 1094 result.buffer = True 1095 1096 class Foo(unittest.TestCase): 1097 @classmethod 1098 def setUpClass(cls): 1099 print('set up class') 1100 cls.addClassCleanup(bad_cleanup1) 1101 cls.addClassCleanup(bad_cleanup2) 1102 @classmethod 1103 def tearDownClass(cls): 1104 print('tear down class') 1105 def test_foo(self): 1106 pass 1107 suite = unittest.TestSuite([Foo('test_foo')]) 1108 suite(result) 1109 expected_out = '\nStdout:\ntear down class\ndo cleanup2\ndo cleanup1\n' 1110 self.assertEqual(stdout.getvalue(), expected_out) 1111 self.assertEqual(len(result.errors), 2) 1112 description = f'tearDownClass ({strclass(Foo)})' 1113 test_case, formatted_exc = result.errors[0] 1114 self.assertEqual(test_case.description, description) 1115 self.assertIn('ValueError: bad cleanup2', formatted_exc) 1116 self.assertNotIn('TypeError', formatted_exc) 1117 self.assertIn(expected_out, formatted_exc) 1118 test_case, formatted_exc = result.errors[1] 1119 self.assertEqual(test_case.description, description) 1120 self.assertIn('TypeError: bad cleanup1', formatted_exc) 1121 self.assertNotIn('ValueError', formatted_exc) 1122 self.assertIn(expected_out, formatted_exc) 1123 1124 def testBufferSetupClass_DoClassCleanups(self): 1125 with captured_stdout() as stdout: 1126 result = unittest.TestResult() 1127 result.buffer = True 1128 1129 class Foo(unittest.TestCase): 1130 @classmethod 1131 def setUpClass(cls): 1132 print('set up class') 1133 cls.addClassCleanup(bad_cleanup1) 1134 cls.addClassCleanup(bad_cleanup2) 1135 1/0 1136 def test_foo(self): 1137 pass 1138 suite = unittest.TestSuite([Foo('test_foo')]) 1139 suite(result) 1140 expected_out = '\nStdout:\nset up class\ndo cleanup2\ndo cleanup1\n' 1141 self.assertEqual(stdout.getvalue(), expected_out) 1142 self.assertEqual(len(result.errors), 3) 1143 description = f'setUpClass ({strclass(Foo)})' 1144 test_case, formatted_exc = result.errors[0] 1145 self.assertEqual(test_case.description, description) 1146 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 1147 self.assertNotIn('ValueError', formatted_exc) 1148 self.assertNotIn('TypeError', formatted_exc) 1149 self.assertIn('\nStdout:\nset up class\n', formatted_exc) 1150 test_case, formatted_exc = result.errors[1] 1151 self.assertEqual(test_case.description, description) 1152 self.assertIn('ValueError: bad cleanup2', formatted_exc) 1153 self.assertNotIn('ZeroDivisionError', formatted_exc) 1154 self.assertNotIn('TypeError', formatted_exc) 1155 self.assertIn(expected_out, formatted_exc) 1156 test_case, formatted_exc = result.errors[2] 1157 self.assertEqual(test_case.description, description) 1158 self.assertIn('TypeError: bad cleanup1', formatted_exc) 1159 self.assertNotIn('ZeroDivisionError', formatted_exc) 1160 self.assertNotIn('ValueError', formatted_exc) 1161 self.assertIn(expected_out, formatted_exc) 1162 1163 def testBufferTearDownClass_DoClassCleanups(self): 1164 with captured_stdout() as stdout: 1165 result = unittest.TestResult() 1166 result.buffer = True 1167 1168 class Foo(unittest.TestCase): 1169 @classmethod 1170 def setUpClass(cls): 1171 print('set up class') 1172 cls.addClassCleanup(bad_cleanup1) 1173 cls.addClassCleanup(bad_cleanup2) 1174 @classmethod 1175 def tearDownClass(cls): 1176 print('tear down class') 1177 1/0 1178 def test_foo(self): 1179 pass 1180 suite = unittest.TestSuite([Foo('test_foo')]) 1181 suite(result) 1182 expected_out = '\nStdout:\ntear down class\ndo cleanup2\ndo cleanup1\n' 1183 self.assertEqual(stdout.getvalue(), expected_out) 1184 self.assertEqual(len(result.errors), 3) 1185 description = f'tearDownClass ({strclass(Foo)})' 1186 test_case, formatted_exc = result.errors[0] 1187 self.assertEqual(test_case.description, description) 1188 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 1189 self.assertNotIn('ValueError', formatted_exc) 1190 self.assertNotIn('TypeError', formatted_exc) 1191 self.assertIn('\nStdout:\ntear down class\n', formatted_exc) 1192 test_case, formatted_exc = result.errors[1] 1193 self.assertEqual(test_case.description, description) 1194 self.assertIn('ValueError: bad cleanup2', formatted_exc) 1195 self.assertNotIn('ZeroDivisionError', formatted_exc) 1196 self.assertNotIn('TypeError', formatted_exc) 1197 self.assertIn(expected_out, formatted_exc) 1198 test_case, formatted_exc = result.errors[2] 1199 self.assertEqual(test_case.description, description) 1200 self.assertIn('TypeError: bad cleanup1', formatted_exc) 1201 self.assertNotIn('ZeroDivisionError', formatted_exc) 1202 self.assertNotIn('ValueError', formatted_exc) 1203 self.assertIn(expected_out, formatted_exc) 1204 1205 def testBufferSetUpModule(self): 1206 with captured_stdout() as stdout: 1207 result = unittest.TestResult() 1208 result.buffer = True 1209 1210 class Foo(unittest.TestCase): 1211 def test_foo(self): 1212 pass 1213 class Module(object): 1214 @staticmethod 1215 def setUpModule(): 1216 print('set up module') 1217 1/0 1218 1219 Foo.__module__ = 'Module' 1220 sys.modules['Module'] = Module 1221 self.addCleanup(sys.modules.pop, 'Module') 1222 suite = unittest.TestSuite([Foo('test_foo')]) 1223 suite(result) 1224 expected_out = '\nStdout:\nset up module\n' 1225 self.assertEqual(stdout.getvalue(), expected_out) 1226 self.assertEqual(len(result.errors), 1) 1227 description = 'setUpModule (Module)' 1228 test_case, formatted_exc = result.errors[0] 1229 self.assertEqual(test_case.description, description) 1230 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 1231 self.assertIn(expected_out, formatted_exc) 1232 1233 def testBufferTearDownModule(self): 1234 with captured_stdout() as stdout: 1235 result = unittest.TestResult() 1236 result.buffer = True 1237 1238 class Foo(unittest.TestCase): 1239 def test_foo(self): 1240 pass 1241 class Module(object): 1242 @staticmethod 1243 def tearDownModule(): 1244 print('tear down module') 1245 1/0 1246 1247 Foo.__module__ = 'Module' 1248 sys.modules['Module'] = Module 1249 self.addCleanup(sys.modules.pop, 'Module') 1250 suite = unittest.TestSuite([Foo('test_foo')]) 1251 suite(result) 1252 expected_out = '\nStdout:\ntear down module\n' 1253 self.assertEqual(stdout.getvalue(), expected_out) 1254 self.assertEqual(len(result.errors), 1) 1255 description = 'tearDownModule (Module)' 1256 test_case, formatted_exc = result.errors[0] 1257 self.assertEqual(test_case.description, description) 1258 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 1259 self.assertIn(expected_out, formatted_exc) 1260 1261 def testBufferDoModuleCleanups(self): 1262 with captured_stdout() as stdout: 1263 result = unittest.TestResult() 1264 result.buffer = True 1265 1266 class Foo(unittest.TestCase): 1267 def test_foo(self): 1268 pass 1269 class Module(object): 1270 @staticmethod 1271 def setUpModule(): 1272 print('set up module') 1273 unittest.addModuleCleanup(bad_cleanup1) 1274 unittest.addModuleCleanup(bad_cleanup2) 1275 1276 Foo.__module__ = 'Module' 1277 sys.modules['Module'] = Module 1278 self.addCleanup(sys.modules.pop, 'Module') 1279 suite = unittest.TestSuite([Foo('test_foo')]) 1280 suite(result) 1281 expected_out = '\nStdout:\ndo cleanup2\ndo cleanup1\n' 1282 self.assertEqual(stdout.getvalue(), expected_out) 1283 self.assertEqual(len(result.errors), 1) 1284 description = 'tearDownModule (Module)' 1285 test_case, formatted_exc = result.errors[0] 1286 self.assertEqual(test_case.description, description) 1287 self.assertIn('ValueError: bad cleanup2', formatted_exc) 1288 self.assertNotIn('TypeError', formatted_exc) 1289 self.assertIn(expected_out, formatted_exc) 1290 1291 def testBufferSetUpModule_DoModuleCleanups(self): 1292 with captured_stdout() as stdout: 1293 result = unittest.TestResult() 1294 result.buffer = True 1295 1296 class Foo(unittest.TestCase): 1297 def test_foo(self): 1298 pass 1299 class Module(object): 1300 @staticmethod 1301 def setUpModule(): 1302 print('set up module') 1303 unittest.addModuleCleanup(bad_cleanup1) 1304 unittest.addModuleCleanup(bad_cleanup2) 1305 1/0 1306 1307 Foo.__module__ = 'Module' 1308 sys.modules['Module'] = Module 1309 self.addCleanup(sys.modules.pop, 'Module') 1310 suite = unittest.TestSuite([Foo('test_foo')]) 1311 suite(result) 1312 expected_out = '\nStdout:\nset up module\ndo cleanup2\ndo cleanup1\n' 1313 self.assertEqual(stdout.getvalue(), expected_out) 1314 self.assertEqual(len(result.errors), 2) 1315 description = 'setUpModule (Module)' 1316 test_case, formatted_exc = result.errors[0] 1317 self.assertEqual(test_case.description, description) 1318 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 1319 self.assertNotIn('ValueError', formatted_exc) 1320 self.assertNotIn('TypeError', formatted_exc) 1321 self.assertIn('\nStdout:\nset up module\n', formatted_exc) 1322 test_case, formatted_exc = result.errors[1] 1323 self.assertIn(expected_out, formatted_exc) 1324 self.assertEqual(test_case.description, description) 1325 self.assertIn('ValueError: bad cleanup2', formatted_exc) 1326 self.assertNotIn('ZeroDivisionError', formatted_exc) 1327 self.assertNotIn('TypeError', formatted_exc) 1328 self.assertIn(expected_out, formatted_exc) 1329 1330 def testBufferTearDownModule_DoModuleCleanups(self): 1331 with captured_stdout() as stdout: 1332 result = unittest.TestResult() 1333 result.buffer = True 1334 1335 class Foo(unittest.TestCase): 1336 def test_foo(self): 1337 pass 1338 class Module(object): 1339 @staticmethod 1340 def setUpModule(): 1341 print('set up module') 1342 unittest.addModuleCleanup(bad_cleanup1) 1343 unittest.addModuleCleanup(bad_cleanup2) 1344 @staticmethod 1345 def tearDownModule(): 1346 print('tear down module') 1347 1/0 1348 1349 Foo.__module__ = 'Module' 1350 sys.modules['Module'] = Module 1351 self.addCleanup(sys.modules.pop, 'Module') 1352 suite = unittest.TestSuite([Foo('test_foo')]) 1353 suite(result) 1354 expected_out = '\nStdout:\ntear down module\ndo cleanup2\ndo cleanup1\n' 1355 self.assertEqual(stdout.getvalue(), expected_out) 1356 self.assertEqual(len(result.errors), 2) 1357 description = 'tearDownModule (Module)' 1358 test_case, formatted_exc = result.errors[0] 1359 self.assertEqual(test_case.description, description) 1360 self.assertIn('ZeroDivisionError: division by zero', formatted_exc) 1361 self.assertNotIn('ValueError', formatted_exc) 1362 self.assertNotIn('TypeError', formatted_exc) 1363 self.assertIn('\nStdout:\ntear down module\n', formatted_exc) 1364 test_case, formatted_exc = result.errors[1] 1365 self.assertEqual(test_case.description, description) 1366 self.assertIn('ValueError: bad cleanup2', formatted_exc) 1367 self.assertNotIn('ZeroDivisionError', formatted_exc) 1368 self.assertNotIn('TypeError', formatted_exc) 1369 self.assertIn(expected_out, formatted_exc) 1370 1371 1372if __name__ == '__main__': 1373 unittest.main() 1374