17     """A simple test suite that doesn't provide class or module shared fixtures.
39         for test in self:
40             if test:
41                 cases += test.countTestCases()
44     def addTest(self, test):  argument
46         if not callable(test):
47             raise TypeError("{} is not callable".format(repr(test)))
48         if isinstance(test, type) and issubclass(test,
52         self._tests.append(test)
57         for test in tests:
58             self.addTest(test)
60     def run(self, result):  argument
61         for index, test in enumerate(self):
62             if result.shouldStop:
64             test(result)
67         return result
72             test = self._tests[index]
79             if hasattr(test, 'countTestCases'):
80                 self._removed_tests += test.countTestCases()
88         for test in self:
89             test.debug()
93     """A test suite is a composite test consisting of a number of TestCases.
95     For use, create an instance of TestSuite, then add test case instances.
96     When all tests have been added, the suite can be passed to a test
97     runner, such as TextTestRunner. It will run the individual test cases
102     def run(self, result, debug=False):  argument
104         if getattr(result, '_testRunEntered', False) is False:
105             result._testRunEntered = topLevel = True
107         for index, test in enumerate(self):
108             if result.shouldStop:
111             if _isnotsuite(test):
112                 self._tearDownPreviousClass(test, result)
113                 self._handleModuleFixture(test, result)
114                 self._handleClassSetUp(test, result)
115                 result._previousTestClass = test.__class__
117                 if (getattr(test.__class__, '_classSetupFailed', False) or
118                     getattr(result, '_moduleSetUpFailed', False)):
122                 test(result)
124                 test.debug()
130             self._tearDownPreviousClass(None, result)
131             self._handleModuleTearDown(result)
132             result._testRunEntered = False
133         return result
142     def _handleClassSetUp(self, test, result):  argument
143         previousClass = getattr(result, '_previousTestClass', None)
144         currentClass = test.__class__
147         if result._moduleSetUpFailed:
156             # test may actually be a function
157             # so its class will be a builtin-type
163             _call_if_exists(result, '_setupStdout')
168                     if isinstance(result, _DebugResult):
176                     self._createClassOrModuleLevelException(result, e,
183                                 result, exc_info[1], 'setUpClass', className,
186                 _call_if_exists(result, '_restoreStdout')
188     def _get_previous_module(self, result):  argument
190         previousClass = getattr(result, '_previousTestClass', None)
196     def _handleModuleFixture(self, test, result):  argument
197         previousModule = self._get_previous_module(result)
198         currentModule = test.__class__.__module__
202         self._handleModuleTearDown(result)
205         result._moduleSetUpFailed = False
212             _call_if_exists(result, '_setupStdout')
217                     if isinstance(result, _DebugResult):
219                     result._moduleSetUpFailed = True
220                     self._createClassOrModuleLevelException(result, e,
223                 if result._moduleSetUpFailed:
227                         self._createClassOrModuleLevelException(result, e,
231                 _call_if_exists(result, '_restoreStdout')
233     def _createClassOrModuleLevelException(self, result, exc, method_name,  argument
236         self._addClassOrModuleLevelException(result, exc, errorName, info)
238     def _addClassOrModuleLevelException(self, result, exception, errorName,  argument
241         addSkip = getattr(result, 'addSkip', None)
246                 result.addError(error, sys.exc_info())
248                 result.addError(error, info)
250     def _handleModuleTearDown(self, result):  argument
251         previousModule = self._get_previous_module(result)
254         if result._moduleSetUpFailed:
262         _call_if_exists(result, '_setupStdout')
269                     if isinstance(result, _DebugResult):
271                     self._createClassOrModuleLevelException(result, e,
277                 if isinstance(result, _DebugResult):
279                 self._createClassOrModuleLevelException(result, e,
283             _call_if_exists(result, '_restoreStdout')
285     def _tearDownPreviousClass(self, test, result):  argument
286         previousClass = getattr(result, '_previousTestClass', None)
287         currentClass = test.__class__
292         if getattr(result, '_moduleSetUpFailed', False):
302         _call_if_exists(result, '_setupStdout')
308                     if isinstance(result, _DebugResult):
311                     self._createClassOrModuleLevelException(result, e,
317                     if isinstance(result, _DebugResult):
320                     self._createClassOrModuleLevelException(result, exc_info[1],
325             _call_if_exists(result, '_restoreStdout')
330     Placeholder for a TestCase inside a result. As far as a TestResult
331     is concerned, this looks exactly like a unit test. Used to insert
332     arbitrary errors into a test suite run.
355     def run(self, result):  argument
356         # could call result.addError(...) - but this test-like object
360     def __call__(self, result):  argument
361         return self.run(result)
366 def _isnotsuite(test):  argument
367     "A crude way to tell apart testcases and suites with duck-typing"
369         iter(test)