AppPkg/Applications/Python/Python-2.7.2/Lib/unittest/test/test_runner.py

   1 import unittest
   2
   3 from cStringIO import StringIO
   4 import pickle
   5
   6 from .support import LoggingResult, ResultWithNoStartTestRunStopTestRun
   7
   8
   9 class TestCleanUp(unittest.TestCase):
  10
  11     def testCleanUp(self):
  12         class TestableTest(unittest.TestCase):
  13             def testNothing(self):
  14                 pass
  15
  16         test = TestableTest('testNothing')
  17         self.assertEqual(test._cleanups, [])
  18
  19         cleanups = []
  20
  21         def cleanup1(*args, **kwargs):
  22             cleanups.append((1, args, kwargs))
  23
  24         def cleanup2(*args, **kwargs):
  25             cleanups.append((2, args, kwargs))
  26
  27         test.addCleanup(cleanup1, 1, 2, 3, four='hello', five='goodbye')
  28         test.addCleanup(cleanup2)
  29
  30         self.assertEqual(test._cleanups,
  31                          [(cleanup1, (1, 2, 3), dict(four='hello', five='goodbye')),
  32                           (cleanup2, (), {})])
  33
  34         result = test.doCleanups()
  35         self.assertTrue(result)
  36
  37         self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3),
  38                                     dict(four='hello', five='goodbye'))])
  39
  40     def testCleanUpWithErrors(self):
  41         class TestableTest(unittest.TestCase):
  42             def testNothing(self):
  43                 pass
  44
  45         class MockResult(object):
  46             errors = []
  47             def addError(self, test, exc_info):
  48                 self.errors.append((test, exc_info))
  49
  50         result = MockResult()
  51         test = TestableTest('testNothing')
  52         test._resultForDoCleanups = result
  53
  54         exc1 = Exception('foo')
  55         exc2 = Exception('bar')
  56         def cleanup1():
  57             raise exc1
  58
  59         def cleanup2():
  60             raise exc2
  61
  62         test.addCleanup(cleanup1)
  63         test.addCleanup(cleanup2)
  64
  65         self.assertFalse(test.doCleanups())
  66
  67         (test1, (Type1, instance1, _)), (test2, (Type2, instance2, _)) = reversed(MockResult.errors)
  68         self.assertEqual((test1, Type1, instance1), (test, Exception, exc1))
  69         self.assertEqual((test2, Type2, instance2), (test, Exception, exc2))
  70
  71     def testCleanupInRun(self):
  72         blowUp = False
  73         ordering = []
  74
  75         class TestableTest(unittest.TestCase):
  76             def setUp(self):
  77                 ordering.append('setUp')
  78                 if blowUp:
  79                     raise Exception('foo')
  80
  81             def testNothing(self):
  82                 ordering.append('test')
  83
  84             def tearDown(self):
  85                 ordering.append('tearDown')
  86
  87         test = TestableTest('testNothing')
  88
  89         def cleanup1():
  90             ordering.append('cleanup1')
  91         def cleanup2():
  92             ordering.append('cleanup2')
  93         test.addCleanup(cleanup1)
  94         test.addCleanup(cleanup2)
  95
  96         def success(some_test):
  97             self.assertEqual(some_test, test)
  98             ordering.append('success')
  99
 100         result = unittest.TestResult()
 101         result.addSuccess = success
 102
 103         test.run(result)
 104         self.assertEqual(ordering, ['setUp', 'test', 'tearDown',
 105                                     'cleanup2', 'cleanup1', 'success'])
 106
 107         blowUp = True
 108         ordering = []
 109         test = TestableTest('testNothing')
 110         test.addCleanup(cleanup1)
 111         test.run(result)
 112         self.assertEqual(ordering, ['setUp', 'cleanup1'])
 113
 114     def testTestCaseDebugExecutesCleanups(self):
 115         ordering = []
 116
 117         class TestableTest(unittest.TestCase):
 118             def setUp(self):
 119                 ordering.append('setUp')
 120                 self.addCleanup(cleanup1)
 121
 122             def testNothing(self):
 123                 ordering.append('test')
 124
 125             def tearDown(self):
 126                 ordering.append('tearDown')
 127
 128         test = TestableTest('testNothing')
 129
 130         def cleanup1():
 131             ordering.append('cleanup1')
 132             test.addCleanup(cleanup2)
 133         def cleanup2():
 134             ordering.append('cleanup2')
 135
 136         test.debug()
 137         self.assertEqual(ordering, ['setUp', 'test', 'tearDown', 'cleanup1', 'cleanup2'])
 138
 139
 140 class Test_TextTestRunner(unittest.TestCase):
 141     """Tests for TextTestRunner."""
 142
 143     def test_init(self):
 144         runner = unittest.TextTestRunner()
 145         self.assertFalse(runner.failfast)
 146         self.assertFalse(runner.buffer)
 147         self.assertEqual(runner.verbosity, 1)
 148         self.assertTrue(runner.descriptions)
 149         self.assertEqual(runner.resultclass, unittest.TextTestResult)
 150
 151
 152     def testBufferAndFailfast(self):
 153         class Test(unittest.TestCase):
 154             def testFoo(self):
 155                 pass
 156         result = unittest.TestResult()
 157         runner = unittest.TextTestRunner(stream=StringIO(), failfast=True,
 158                                            buffer=True)
 159         # Use our result object
 160         runner._makeResult = lambda: result
 161         runner.run(Test('testFoo'))
 162
 163         self.assertTrue(result.failfast)
 164         self.assertTrue(result.buffer)
 165
 166     def testRunnerRegistersResult(self):
 167         class Test(unittest.TestCase):
 168             def testFoo(self):
 169                 pass
 170         originalRegisterResult = unittest.runner.registerResult
 171         def cleanup():
 172             unittest.runner.registerResult = originalRegisterResult
 173         self.addCleanup(cleanup)
 174
 175         result = unittest.TestResult()
 176         runner = unittest.TextTestRunner(stream=StringIO())
 177         # Use our result object
 178         runner._makeResult = lambda: result
 179
 180         self.wasRegistered = 0
 181         def fakeRegisterResult(thisResult):
 182             self.wasRegistered += 1
 183             self.assertEqual(thisResult, result)
 184         unittest.runner.registerResult = fakeRegisterResult
 185
 186         runner.run(unittest.TestSuite())
 187         self.assertEqual(self.wasRegistered, 1)
 188
 189     def test_works_with_result_without_startTestRun_stopTestRun(self):
 190         class OldTextResult(ResultWithNoStartTestRunStopTestRun):
 191             separator2 = ''
 192             def printErrors(self):
 193                 pass
 194
 195         class Runner(unittest.TextTestRunner):
 196             def __init__(self):
 197                 super(Runner, self).__init__(StringIO())
 198
 199             def _makeResult(self):
 200                 return OldTextResult()
 201
 202         runner = Runner()
 203         runner.run(unittest.TestSuite())
 204
 205     def test_startTestRun_stopTestRun_called(self):
 206         class LoggingTextResult(LoggingResult):
 207             separator2 = ''
 208             def printErrors(self):
 209                 pass
 210
 211         class LoggingRunner(unittest.TextTestRunner):
 212             def __init__(self, events):
 213                 super(LoggingRunner, self).__init__(StringIO())
 214                 self._events = events
 215
 216             def _makeResult(self):
 217                 return LoggingTextResult(self._events)
 218
 219         events = []
 220         runner = LoggingRunner(events)
 221         runner.run(unittest.TestSuite())
 222         expected = ['startTestRun', 'stopTestRun']
 223         self.assertEqual(events, expected)
 224
 225     def test_pickle_unpickle(self):
 226         # Issue #7197: a TextTestRunner should be (un)pickleable. This is
 227         # required by test_multiprocessing under Windows (in verbose mode).
 228         from StringIO import StringIO as PickleableIO
 229         # cStringIO objects are not pickleable, but StringIO objects are.
 230         stream = PickleableIO("foo")
 231         runner = unittest.TextTestRunner(stream)
 232         for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
 233             s = pickle.dumps(runner, protocol=protocol)
 234             obj = pickle.loads(s)
 235             # StringIO objects never compare equal, a cheap test instead.
 236             self.assertEqual(obj.stream.getvalue(), stream.getvalue())
 237
 238     def test_resultclass(self):
 239         def MockResultClass(*args):
 240             return args
 241         STREAM = object()
 242         DESCRIPTIONS = object()
 243         VERBOSITY = object()
 244         runner = unittest.TextTestRunner(STREAM, DESCRIPTIONS, VERBOSITY,
 245                                          resultclass=MockResultClass)
 246         self.assertEqual(runner.resultclass, MockResultClass)
 247
 248         expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY)
 249         self.assertEqual(runner._makeResult(), expectedresult)
 250
 251
 252 if __name__ == '__main__':
 253     unittest.main()