.. versionchanged:: 3.1
-
- Added :ref:`skipping and expected failures <unittest-skipping>`.
+ Added test :ref:`skipping and expected failures <unittest-skipping>`.
The Python unit testing framework, sometimes referred to as "PyUnit," is a
Python language version of JUnit, by Kent Beck and Erich Gamma. JUnit is, in
:class:`TestCase` and :class:`FunctionTestCase` classes; the former should be
used when creating new tests, and the latter can be used when integrating
existing test code with a :mod:`unittest`\ -driven framework. When building test
-fixtures using :class:`TestCase`, the :meth:`setUp` and :meth:`tearDown` methods
-can be overridden to provide initialization and cleanup for the fixture. With
-:class:`FunctionTestCase`, existing functions can be passed to the constructor
-for these purposes. When the test is run, the fixture initialization is run
-first; if it succeeds, the cleanup method is run after the test has been
-executed, regardless of the outcome of the test. Each instance of the
-:class:`TestCase` will only be used to run a single test method, so a new
-fixture is created for each test.
+fixtures using :class:`TestCase`, the :meth:`~TestCase.setUp` and
+:meth:`~TestCase.tearDown` methods can be overridden to provide initialization
+and cleanup for the fixture. With :class:`FunctionTestCase`, existing functions
+can be passed to the constructor for these purposes. When the test is run, the
+fixture initialization is run first; if it succeeds, the cleanup method is run
+after the test has been executed, regardless of the outcome of the test. Each
+instance of the :class:`TestCase` will only be used to run a single test method,
+so a new fixture is created for each test.
Test suites are implemented by the :class:`TestSuite` class. This class allows
individual tests and test suites to be aggregated; when the suite is executed,
all tests added directly to the suite and in "child" test suites are run. A
:class:`ClassTestSuite` contains the test cases of a class.
-A test runner is an object that provides a single method, :meth:`run`, which
-accepts a :class:`TestCase` or :class:`TestSuite` object as a parameter, and
-returns a result object. The class :class:`TestResult` is provided for use as
-the result object. :mod:`unittest` provides the :class:`TextTestRunner` as an
-example test runner which reports test results on the standard error stream by
-default. Alternate runners can be implemented for other environments (such as
-graphical environments) without any need to derive from a specific class.
+A test runner is an object that provides a single method,
+:meth:`~TestRunner.run`, which accepts a :class:`TestCase` or :class:`TestSuite`
+object as a parameter, and returns a result object. The class
+:class:`TestResult` is provided for use as the result object. :mod:`unittest`
+provides the :class:`TextTestRunner` as an example test runner which reports
+test results on the standard error stream by default. Alternate runners can be
+implemented for other environments (such as graphical environments) without any
+need to derive from a specific class.
.. seealso::
def setUp(self):
self.seq = range(10)
- def testshuffle(self):
+ def test_shuffle(self):
# make sure the shuffled sequence does not lose any elements
random.shuffle(self.seq)
self.seq.sort()
self.assertEqual(self.seq, range(10))
- def testchoice(self):
+ def test_choice(self):
element = random.choice(self.seq)
self.assert_(element in self.seq)
- def testsample(self):
+ def test_sample(self):
self.assertRaises(ValueError, random.sample, self.seq, 20)
for element in random.sample(self.seq, 5):
self.assert_(element in self.seq)
if __name__ == '__main__':
unittest.main()
-A testcase is created by subclassing :class:`unittest.TestCase`. The three
+A testcase is created by subclassing :class:`unittest.TestCase`. The three
individual tests are defined with methods whose names start with the letters
``test``. This naming convention informs the test runner about which methods
represent tests.
-The crux of each test is a call to :meth:`assertEqual` to check for an expected
-result; :meth:`assert_` to verify a condition; or :meth:`assertRaises` to verify
-that an expected exception gets raised. These methods are used instead of the
-:keyword:`assert` statement so the test runner can accumulate all test results
-and produce a report.
+The crux of each test is a call to :meth:`~TestCase.assertEqual` to check for an
+expected result; :meth:`~TestCase.assert_` to verify a condition; or
+:meth:`~TestCase.assertRaises` to verify that an expected exception gets raised.
+These methods are used instead of the :keyword:`assert` statement so the test
+runner can accumulate all test results and produce a report.
-When a :meth:`setUp` method is defined, the test runner will run that method
-prior to each test. Likewise, if a :meth:`tearDown` method is defined, the test
-runner will invoke that method after each test. In the example, :meth:`setUp`
-was used to create a fresh sequence for each test.
+When a :meth:`~TestCase.setUp` method is defined, the test runner will run that
+method prior to each test. Likewise, if a :meth:`~TestCase.tearDown` method is
+defined, the test runner will invoke that method after each test. In the
+example, :meth:`~TestCase.setUp` was used to create a fresh sequence for each
+test.
The final block shows a simple way to run the tests. :func:`unittest.main`
provides a command line interface to the test script. When run from the command
contained, such that it can be run either in isolation or in arbitrary
combination with any number of other test cases.
-The simplest :class:`TestCase` subclass will simply override the :meth:`runTest`
-method in order to perform specific testing code::
+The simplest :class:`TestCase` subclass will simply override the
+:meth:`~TestCase.runTest` method in order to perform specific testing code::
import unittest
subclasses would mean unsightly duplication.
Luckily, we can factor out such set-up code by implementing a method called
-:meth:`setUp`, which the testing framework will automatically call for us when
-we run the test::
+:meth:`~TestCase.setUp`, which the testing framework will automatically call for
+us when we run the test::
import unittest
self.failUnless(self.widget.size() == (100,150),
'wrong size after resize')
-If the :meth:`setUp` method raises an exception while the test is running, the
-framework will consider the test to have suffered an error, and the
-:meth:`runTest` method will not be executed.
+If the :meth:`~TestCase.setUp` method raises an exception while the test is
+running, the framework will consider the test to have suffered an error, and the
+:meth:`~TestCase.runTest` method will not be executed.
-Similarly, we can provide a :meth:`tearDown` method that tidies up after the
-:meth:`runTest` method has been run::
+Similarly, we can provide a :meth:`~TestCase.tearDown` method that tidies up
+after the :meth:`~TestCase.runTest` method has been run::
import unittest
self.widget.dispose()
self.widget = None
-If :meth:`setUp` succeeded, the :meth:`tearDown` method will be run whether
-:meth:`runTest` succeeded or not.
+If :meth:`~TestCase.setUp` succeeded, the :meth:`~TestCase.tearDown` method will
+be run whether :meth:`~TestCase.runTest` succeeded or not.
Such a working environment for the testing code is called a :dfn:`fixture`.
self.failUnless(self.widget.size() == (100,150),
'wrong size after resize')
-Here we have not provided a :meth:`runTest` method, but have instead provided
-two different test methods. Class instances will now each run one of the
-:meth:`test\*` methods, with ``self.widget`` created and destroyed separately
-for each instance. When creating an instance we must specify the test method it
-is to run. We do this by passing the method name in the constructor::
+Here we have not provided a :meth:`~TestCase.runTest` method, but have instead
+provided two different test methods. Class instances will now each run one of
+the :meth:`test\*` methods, with ``self.widget`` created and destroyed
+separately for each instance. When creating an instance we must specify the
+test method it is to run. We do this by passing the method name in the
+constructor::
defaultSizeTestCase = WidgetTestCase('testDefaultSize')
resizeTestCase = WidgetTestCase('testResize')
recommended. Taking the time to set up proper :class:`TestCase` subclasses will
make future test refactorings infinitely easier.
+In some cases, the existing tests may have been written using the :mod:`doctest`
+module. If so, :mod:`doctest` provides a :class:`DocTestSuite` class that can
+automatically build :class:`unittest.TestSuite` instances from the existing
+:mod:`doctest`\ -based tests.
+
.. _unittest-skipping:
def test_not_run(self):
pass
+:meth:`TestCase.setUp` can also skip the test. This is useful when a resource
+that needs to be set up is not available.
+
Expected failures use the :func:`expectedFailure` decorator. ::
class ExpectedFailureTestCase(unittest.TestCase):
Classes and functions
---------------------
+This section describes in depth the API of :mod:`unittest`.
+
+
+.. _testcase-objects:
+
+Test cases
+~~~~~~~~~~
.. class:: TestCase([methodName])
Here, we create two instances of :class:`WidgetTestCase`, each of which runs a
single test.
- *methodName* defaults to ``'runTest'``.
+ *methodName* defaults to :meth:`runTest`.
+ :class:`TestCase` instances provide three groups of methods: one group used
+ to run the test, another used by the test implementation to check conditions
+ and report failures, and some inquiry methods allowing information about the
+ test itself to be gathered.
-.. class:: FunctionTestCase(testFunc[, setUp[, tearDown[, description]]])
+ Methods in the first group (running the test) are:
- This class implements the portion of the :class:`TestCase` interface which
- allows the test runner to drive the test, but does not provide the methods which
- test code can use to check and report errors. This is used to create test cases
- using legacy test code, allowing it to be integrated into a :mod:`unittest`\
- -based test framework.
+ .. method:: setUp()
-.. class:: TestSuite([tests])
+ Method called to prepare the test fixture. This is called immediately
+ before calling the test method; any exception raised by this method will
+ be considered an error rather than a test failure. The default
+ implementation does nothing.
- This class represents an aggregation of individual tests cases and test suites.
- The class presents the interface needed by the test runner to allow it to be run
- as any other test case. Running a :class:`TestSuite` instance is the same as
- iterating over the suite, running each test individually.
- If *tests* is given, it must be an iterable of individual test cases or other
- test suites that will be used to build the suite initially. Additional methods
- are provided to add test cases and suites to the collection later on.
+ .. method:: tearDown()
-.. class:: ClassTestSuite(tests, collected_from)
+ Method called immediately after the test method has been called and the
+ result recorded. This is called even if the test method raised an
+ exception, so the implementation in subclasses may need to be particularly
+ careful about checking internal state. Any exception raised by this
+ method will be considered an error rather than a test failure. This
+ method will only be called if the :meth:`setUp` succeeds, regardless of
+ the outcome of the test method. The default implementation does nothing.
- This subclass of :class:`TestSuite` repesents an aggregation of individuals
- tests from one :class:`TestCase` class. *tests* is an iterable of
- :class:`TestCase` instances created from the class. *collected_from* is the
- class they came from.
+ .. method:: run([result])
-.. class:: TestLoader()
+ Run the test, collecting the result into the test result object passed as
+ *result*. If *result* is omitted or :const:`None`, a temporary result
+ object is created (by calling the :meth:`defaultTestCase` method) and
+ used; this result object is not returned to :meth:`run`'s caller.
- This class is responsible for loading tests according to various criteria and
- returning them wrapped in a :class:`TestSuite`. It can load all tests within a
- given module or :class:`TestCase` subclass.
+ The same effect may be had by simply calling the :class:`TestCase`
+ instance.
-.. class:: TestResult()
+ .. method:: skip(reason)
- This class is used to compile information about which tests have succeeded and
- which have failed.
+ Calling this during the a test method or :meth:`setUp` skips the current
+ test. See :ref:`unittest-skipping` for more information.
-.. data:: defaultTestLoader
+ .. method:: debug()
- Instance of the :class:`TestLoader` class intended to be shared. If no
- customization of the :class:`TestLoader` is needed, this instance can be used
- instead of repeatedly creating new instances.
+ Run the test without collecting the result. This allows exceptions raised
+ by the test to be propagated to the caller, and can be used to support
+ running tests under a debugger.
+ The test code can use any of the following methods to check for and report
+ failures.
-.. class:: TextTestRunner([stream[, descriptions[, verbosity]]])
- A basic test runner implementation which prints results on standard error. It
- has a few configurable parameters, but is essentially very simple. Graphical
- applications which run test suites should provide alternate implementations.
+ .. method:: assert_(expr[, msg])
+ failUnless(expr[, msg])
+ assertTrue(expr[, msg])
+ Signal a test failure if *expr* is false; the explanation for the error
+ will be *msg* if given, otherwise it will be :const:`None`.
-.. function:: main([module[, defaultTest[, argv[, testRunner[, testLoader]]]]])
- A command-line program that runs a set of tests; this is primarily for making
- test modules conveniently executable. The simplest use for this function is to
- include the following line at the end of a test script::
+ .. method:: assertEqual(first, second[, msg])
+ failUnlessEqual(first, second[, msg])
- if __name__ == '__main__':
- unittest.main()
+ Test that *first* and *second* are equal. If the values do not compare
+ equal, the test will fail with the explanation given by *msg*, or
+ :const:`None`. Note that using :meth:`failUnlessEqual` improves upon
+ doing the comparison as the first parameter to :meth:`failUnless`: the
+ default value for *msg* can be computed to include representations of both
+ *first* and *second*.
- The *testRunner* argument can either be a test runner class or an already
- created instance of it.
-In some cases, the existing tests may have been written using the :mod:`doctest`
-module. If so, that module provides a :class:`DocTestSuite` class that can
-automatically build :class:`unittest.TestSuite` instances from the existing
-:mod:`doctest`\ -based tests.
+ .. method:: assertNotEqual(first, second[, msg])
+ failIfEqual(first, second[, msg])
+ Test that *first* and *second* are not equal. If the values do compare
+ equal, the test will fail with the explanation given by *msg*, or
+ :const:`None`. Note that using :meth:`failIfEqual` improves upon doing
+ the comparison as the first parameter to :meth:`failUnless` is that the
+ default value for *msg* can be computed to include representations of both
+ *first* and *second*.
-.. _testcase-objects:
+ .. method:: assertAlmostEqual(first, second[, places[, msg]])
+ failUnlessAlmostEqual(first, second[, places[, msg]])
-TestCase Objects
-----------------
+ Test that *first* and *second* are approximately equal by computing the
+ difference, rounding to the given number of decimal *places* (default 7),
+ and comparing to zero.
-Each :class:`TestCase` instance represents a single test, but each concrete
-subclass may be used to define multiple tests --- the concrete class represents
-a single test fixture. The fixture is created and cleaned up for each test
-case.
+ Note that comparing a given number of decimal places is not the same as
+ comparing a given number of significant digits. If the values do not
+ compare equal, the test will fail with the explanation given by *msg*, or
+ :const:`None`.
-:class:`TestCase` instances provide three groups of methods: one group used to
-run the test, another used by the test implementation to check conditions and
-report failures, and some inquiry methods allowing information about the test
-itself to be gathered.
-Methods in the first group (running the test) are:
+ .. method:: assertNotAlmostEqual(first, second[, places[, msg]])
+ failIfAlmostEqual(first, second[, places[, msg]])
+ Test that *first* and *second* are not approximately equal by computing
+ the difference, rounding to the given number of decimal *places* (default
+ 7), and comparing to zero.
-.. method:: TestCase.setUp()
+ Note that comparing a given number of decimal places is not the same as
+ comparing a given number of significant digits. If the values do not
+ compare equal, the test will fail with the explanation given by *msg*, or
+ :const:`None`.
- Method called to prepare the test fixture. This is called immediately before
- calling the test method; any exception raised by this method will be considered
- an error rather than a test failure. The default implementation does nothing.
+ .. method:: assertRaises(exception[, callable, ...])
+ failUnlessRaises(exception[, callable, ...])
-.. method:: TestCase.tearDown()
+ Test that an exception is raised when *callable* is called with any
+ positional or keyword arguments that are also passed to
+ :meth:`assertRaises`. The test passes if *exception* is raised, is an
+ error if another exception is raised, or fails if no exception is raised.
+ To catch any of a group of exceptions, a tuple containing the exception
+ classes may be passed as *exception*.
- Method called immediately after the test method has been called and the result
- recorded. This is called even if the test method raised an exception, so the
- implementation in subclasses may need to be particularly careful about checking
- internal state. Any exception raised by this method will be considered an error
- rather than a test failure. This method will only be called if the
- :meth:`setUp` succeeds, regardless of the outcome of the test method. The
- default implementation does nothing.
+ .. versionchanged:: 2.7
+ If *callable* is omitted or None, returns a context manager so that the
+ code under test can be written inline rather than as a function::
-.. method:: TestCase.run([result])
+ with self.failUnlessRaises(some_error_class):
+ do_something()
- Run the test, collecting the result into the test result object passed as
- *result*. If *result* is omitted or :const:`None`, a temporary result object is
- created (by calling the :meth:`defaultTestCase` method) and used; this result
- object is not returned to :meth:`run`'s caller.
+ .. method:: failIf(expr[, msg])
+ assertFalse(expr[, msg])
- The same effect may be had by simply calling the :class:`TestCase` instance.
+ The inverse of the :meth:`failUnless` method is the :meth:`failIf` method.
+ This signals a test failure if *expr* is true, with *msg* or :const:`None`
+ for the error message.
-.. method:: TestCase.skip(reason)
+ .. method:: fail([msg])
- Skips the current test. See :ref:`unittest-skipping`.
+ Signals a test failure unconditionally, with *msg* or :const:`None` for
+ the error message.
-.. method:: TestCase.debug()
+ .. attribute:: failureException
- Run the test without collecting the result. This allows exceptions raised by
- the test to be propagated to the caller, and can be used to support running
- tests under a debugger.
+ This class attribute gives the exception raised by the test method. If a
+ test framework needs to use a specialized exception, possibly to carry
+ additional information, it must subclass this exception in order to "play
+ fair" with the framework. The initial value of this attribute is
+ :exc:`AssertionError`.
-The test code can use any of the following methods to check for and report
-failures.
+ Testing frameworks can use the following methods to collect information on
+ the test:
-.. method:: TestCase.assert_(expr[, msg])
- TestCase.failUnless(expr[, msg])
- TestCase.assertTrue(expr[, msg])
+ .. method:: countTestCases()
- Signal a test failure if *expr* is false; the explanation for the error will be
- *msg* if given, otherwise it will be :const:`None`.
+ Return the number of tests represented by this test object. For
+ :class:`TestCase` instances, this will always be ``1``.
-.. method:: TestCase.assertEqual(first, second[, msg])
- TestCase.failUnlessEqual(first, second[, msg])
+ .. method:: defaultTestResult()
- Test that *first* and *second* are equal. If the values do not compare equal,
- the test will fail with the explanation given by *msg*, or :const:`None`. Note
- that using :meth:`failUnlessEqual` improves upon doing the comparison as the
- first parameter to :meth:`failUnless`: the default value for *msg* can be
- computed to include representations of both *first* and *second*.
+ Return an instance of the test result class that should be used for this
+ test case class (if no other result instance is provided to the
+ :meth:`run` method).
+ For :class:`TestCase` instances, this will always be an instance of
+ :class:`TestResult`; subclasses of :class:`TestCase` should override this
+ as necessary.
-.. method:: TestCase.assertNotEqual(first, second[, msg])
- TestCase.failIfEqual(first, second[, msg])
- Test that *first* and *second* are not equal. If the values do compare equal,
- the test will fail with the explanation given by *msg*, or :const:`None`. Note
- that using :meth:`failIfEqual` improves upon doing the comparison as the first
- parameter to :meth:`failUnless` is that the default value for *msg* can be
- computed to include representations of both *first* and *second*.
+ .. method:: id()
+ Return a string identifying the specific test case. This is usually the
+ full name of the test method, including the module and class name.
-.. method:: TestCase.assertAlmostEqual(first, second[, places[, msg]])
- TestCase.failUnlessAlmostEqual(first, second[, places[, msg]])
- Test that *first* and *second* are approximately equal by computing the
- difference, rounding to the given number of decimal *places* (default 7),
- and comparing to zero.
- Note that comparing a given number of decimal places is not the same as
- comparing a given number of significant digits. If the values do not compare
- equal, the test will fail with the explanation given by *msg*, or :const:`None`.
+ .. method:: shortDescription()
+ Returns a one-line description of the test, or :const:`None` if no
+ description has been provided. The default implementation of this method
+ returns the first line of the test method's docstring, if available, or
+ :const:`None`.
-.. method:: TestCase.assertNotAlmostEqual(first, second[, places[, msg]])
- TestCase.failIfAlmostEqual(first, second[, places[, msg]])
- Test that *first* and *second* are not approximately equal by computing the
- difference, rounding to the given number of decimal *places* (default 7),
- and comparing to zero.
- Note that comparing a given number of decimal places is not the same as
- comparing a given number of significant digits. If the values do not compare
- equal, the test will fail with the explanation given by *msg*, or :const:`None`.
+.. class:: FunctionTestCase(testFunc[, setUp[, tearDown[, description]]])
+ This class implements the portion of the :class:`TestCase` interface which
+ allows the test runner to drive the test, but does not provide the methods which
+ test code can use to check and report errors. This is used to create test cases
+ using legacy test code, allowing it to be integrated into a :mod:`unittest`\
+ -based test framework.
-.. method:: TestCase.assertRaises(exception[, callable, ...])
- TestCase.failUnlessRaises(exception[, callable, ...])
- Test that an exception is raised when *callable* is called with any positional
- or keyword arguments that are also passed to :meth:`assertRaises`. The test
- passes if *exception* is raised, is an error if another exception is raised, or
- fails if no exception is raised. To catch any of a group of exceptions, a tuple
- containing the exception classes may be passed as *exception*.
+.. _testsuite-objects:
- If *callable* is omitted or None, returns a context manager so that the code
- under test can be written inline rather than as a function::
- with self.failUnlessRaises(some_error_class):
- do_something()
+Grouping tests
+~~~~~~~~~~~~~~
-.. method:: TestCase.failIf(expr[, msg])
- TestCase.assertFalse(expr[, msg])
+.. class:: TestSuite([tests])
- The inverse of the :meth:`failUnless` method is the :meth:`failIf` method. This
- signals a test failure if *expr* is true, with *msg* or :const:`None` for the
- error message.
+ This class represents an aggregation of individual tests cases and test suites.
+ The class presents the interface needed by the test runner to allow it to be run
+ as any other test case. Running a :class:`TestSuite` instance is the same as
+ iterating over the suite, running each test individually.
+ If *tests* is given, it must be an iterable of individual test cases or other
+ test suites that will be used to build the suite initially. Additional methods
+ are provided to add test cases and suites to the collection later on.
-.. method:: TestCase.fail([msg])
+ :class:`TestSuite` (including :class:`ClassTestSuite`) objects behave much
+ like :class:`TestCase` objects, except they do not actually implement a test.
+ Instead, they are used to aggregate tests into groups of tests that should be
+ run together. Some additional methods are available to add tests to
+ :class:`TestSuite` instances:
- Signals a test failure unconditionally, with *msg* or :const:`None` for the
- error message.
+ .. method:: TestSuite.addTest(test)
-.. attribute:: TestCase.failureException
+ Add a :class:`TestCase` or :class:`TestSuite` to the suite.
- This class attribute gives the exception raised by the :meth:`test` method. If
- a test framework needs to use a specialized exception, possibly to carry
- additional information, it must subclass this exception in order to "play fair"
- with the framework. The initial value of this attribute is
- :exc:`AssertionError`.
-Testing frameworks can use the following methods to collect information on the
-test:
+ .. method:: TestSuite.addTests(tests)
+ Add all the tests from an iterable of :class:`TestCase` and :class:`TestSuite`
+ instances to this test suite.
-.. method:: TestCase.countTestCases()
+ This is equivalent to iterating over *tests*, calling :meth:`addTest` for each
+ element.
- Return the number of tests represented by this test object. For
- :class:`TestCase` instances, this will always be ``1``.
+ :class:`TestSuite` shares the following methods with :class:`TestCase`:
-.. method:: TestCase.defaultTestResult()
+ .. method:: run(result)
- Return an instance of the test result class that should be used for this test
- case class (if no other result instance is provided to the :meth:`run` method).
+ Run the tests associated with this suite, collecting the result into the
+ test result object passed as *result*. Note that unlike
+ :meth:`TestCase.run`, :meth:`TestSuite.run` requires the result object to
+ be passed in.
- For :class:`TestCase` instances, this will always be an instance of
- :class:`TestResult`; subclasses of :class:`TestCase` should override this as
- necessary.
+ .. method:: debug()
-.. method:: TestCase.id()
+ Run the tests associated with this suite without collecting the
+ result. This allows exceptions raised by the test to be propagated to the
+ caller and can be used to support running tests under a debugger.
- Return a string identifying the specific test case. This is usually the full
- name of the test method, including the module and class name.
+ .. method:: countTestCases()
-.. method:: TestCase.shortDescription()
+ Return the number of tests represented by this test object, including all
+ individual tests and sub-suites.
- Returns a one-line description of the test, or :const:`None` if no description
- has been provided. The default implementation of this method returns the first
- line of the test method's docstring, if available, or :const:`None`.
+ In the typical usage of a :class:`TestSuite` object, the :meth:`run` method
+ is invoked by a :class:`TestRunner` rather than by the end-user test harness.
-.. _testsuite-objects:
+.. class:: ClassTestSuite(tests, collected_from)
+
+ This subclass of :class:`TestSuite` repesents an aggregation of individuals
+ tests from one :class:`TestCase` class. *tests* is an iterable of
+ :class:`TestCase` instances created from the class. *collected_from* is the
+ class they came from.
-TestSuite Objects
------------------
-:class:`TestSuite` (including :class:`ClassTestSuite`) objects behave much like
-:class:`TestCase` objects, except they do not actually implement a test.
-Instead, they are used to aggregate tests into groups of tests that should be
-run together. Some additional methods are available to add tests to
-:class:`TestSuite` instances:
+Loading and running tests
+~~~~~~~~~~~~~~~~~~~~~~~~~
+.. class:: TestLoader()
-.. method:: TestSuite.addTest(test)
+ The :class:`TestLoader` class is used to create test suites from classes and
+ modules. Normally, there is no need to create an instance of this class; the
+ :mod:`unittest` module provides an instance that can be shared as
+ ``unittest.defaultTestLoader``. Using a subclass or instance, however, allows
+ customization of some configurable properties.
- Add a :class:`TestCase` or :class:`TestSuite` to the suite.
+ :class:`TestLoader` objects have the following methods:
-.. method:: TestSuite.addTests(tests)
+ .. method:: loadTestsFromTestCase(testCaseClass)
- Add all the tests from an iterable of :class:`TestCase` and :class:`TestSuite`
- instances to this test suite.
+ Return a suite of all tests cases contained in the :class:`TestCase`\ -derived
+ :class:`testCaseClass`.
- This is equivalent to iterating over *tests*, calling :meth:`addTest` for each
- element.
-:class:`TestSuite` shares the following methods with :class:`TestCase`:
+ .. method:: loadTestsFromModule(module)
+ Return a suite of all tests cases contained in the given module. This
+ method searches *module* for classes derived from :class:`TestCase` and
+ creates an instance of the class for each test method defined for the
+ class.
-.. method:: TestSuite.run(result)
+ .. warning::
- Run the tests associated with this suite, collecting the result into the test
- result object passed as *result*. Note that unlike :meth:`TestCase.run`,
- :meth:`TestSuite.run` requires the result object to be passed in.
+ While using a hierarchy of :class:`TestCase`\ -derived classes can be
+ convenient in sharing fixtures and helper functions, defining test
+ methods on base classes that are not intended to be instantiated
+ directly does not play well with this method. Doing so, however, can
+ be useful when the fixtures are different and defined in subclasses.
-.. method:: TestSuite.debug()
+ .. method:: loadTestsFromName(name[, module])
- Run the tests associated with this suite without collecting the result. This
- allows exceptions raised by the test to be propagated to the caller and can be
- used to support running tests under a debugger.
+ Return a suite of all tests cases given a string specifier.
+ The specifier *name* is a "dotted name" that may resolve either to a
+ module, a test case class, a test method within a test case class, a
+ :class:`TestSuite` instance, or a callable object which returns a
+ :class:`TestCase` or :class:`TestSuite` instance. These checks are
+ applied in the order listed here; that is, a method on a possible test
+ case class will be picked up as "a test method within a test case class",
+ rather than "a callable object".
-.. method:: TestSuite.countTestCases()
+ For example, if you have a module :mod:`SampleTests` containing a
+ :class:`TestCase`\ -derived class :class:`SampleTestCase` with three test
+ methods (:meth:`test_one`, :meth:`test_two`, and :meth:`test_three`), the
+ specifier ``'SampleTests.SampleTestCase'`` would cause this method to return a
+ suite which will run all three test methods. Using the specifier
+ ``'SampleTests.SampleTestCase.test_two'`` would cause it to return a test suite
+ which will run only the :meth:`test_two` test method. The specifier can refer
+ to modules and packages which have not been imported; they will be imported as a
+ side-effect.
- Return the number of tests represented by this test object, including all
- individual tests and sub-suites.
+ The method optionally resolves *name* relative to the given *module*.
-In the typical usage of a :class:`TestSuite` object, the :meth:`run` method is
-invoked by a :class:`TestRunner` rather than by the end-user test harness.
+ .. method:: loadTestsFromNames(names[, module])
-.. _testresult-objects:
+ Similar to :meth:`loadTestsFromName`, but takes a sequence of names rather
+ than a single name. The return value is a test suite which supports all
+ the tests defined for each name.
-TestResult Objects
-------------------
-A :class:`TestResult` object stores the results of a set of tests. The
-:class:`TestCase` and :class:`TestSuite` classes ensure that results are
-properly recorded; test authors do not need to worry about recording the outcome
-of tests.
+ .. method:: getTestCaseNames(testCaseClass)
-Testing frameworks built on top of :mod:`unittest` may want access to the
-:class:`TestResult` object generated by running a set of tests for reporting
-purposes; a :class:`TestResult` instance is returned by the
-:meth:`TestRunner.run` method for this purpose.
+ Return a sorted sequence of method names found within *testCaseClass*;
+ this should be a subclass of :class:`TestCase`.
-:class:`TestResult` instances have the following attributes that will be of
-interest when inspecting the results of running a set of tests:
+ The following attributes of a :class:`TestLoader` can be configured either by
+ subclassing or assignment on an instance:
-.. attribute:: TestResult.errors
+ .. attribute:: testMethodPrefix
- A list containing 2-tuples of :class:`TestCase` instances and strings holding
- formatted tracebacks. Each tuple represents a test which raised an unexpected
- exception.
+ String giving the prefix of method names which will be interpreted as test
+ methods. The default value is ``'test'``.
+ This affects :meth:`getTestCaseNames` and all the :meth:`loadTestsFrom\*`
+ methods.
-.. attribute:: TestResult.failures
- A list containing 2-tuples of :class:`TestCase` instances and strings holding
- formatted tracebacks. Each tuple represents a test where a failure was
- explicitly signalled using the :meth:`TestCase.fail\*` or
- :meth:`TestCase.assert\*` methods.
+ .. attribute:: sortTestMethodsUsing
+ Function to be used to compare method names when sorting them in
+ :meth:`getTestCaseNames` and all the :meth:`loadTestsFrom\*` methods.
-.. attribute:: TestResult.testsRun
- The total number of tests run so far.
+ .. attribute:: suiteClass
+ Callable object that constructs a test suite from a list of tests. No
+ methods on the resulting object are needed. The default value is the
+ :class:`TestSuite` class.
-.. method:: TestResult.wasSuccessful()
+ This affects all the :meth:`loadTestsFrom\*` methods.
- Returns :const:`True` if all tests run so far have passed, otherwise returns
- :const:`False`.
+ .. attribute:: classSuiteClass
-.. method:: TestResult.stop()
+ Callable object that constructs a test suite for the tests cases from one
+ class. The default value is :class:`ClassTestSuite`.
- This method can be called to signal that the set of tests being run should be
- aborted by setting the :class:`TestResult`'s ``shouldStop`` attribute to
- :const:`True`. :class:`TestRunner` objects should respect this flag and return
- without running any additional tests.
- For example, this feature is used by the :class:`TextTestRunner` class to stop
- the test framework when the user signals an interrupt from the keyboard.
- Interactive tools which provide :class:`TestRunner` implementations can use this
- in a similar manner.
+.. class:: TestResult
-The following methods of the :class:`TestResult` class are used to maintain the
-internal data structures, and may be extended in subclasses to support
-additional reporting requirements. This is particularly useful in building
-tools which support interactive reporting while tests are being run.
+ This class is used to compile information about which tests have succeeded
+ and which have failed.
+ A :class:`TestResult` object stores the results of a set of tests. The
+ :class:`TestCase` and :class:`TestSuite` classes ensure that results are
+ properly recorded; test authors do not need to worry about recording the
+ outcome of tests.
-.. method:: TestResult.startTest(test)
+ Testing frameworks built on top of :mod:`unittest` may want access to the
+ :class:`TestResult` object generated by running a set of tests for reporting
+ purposes; a :class:`TestResult` instance is returned by the
+ :meth:`TestRunner.run` method for this purpose.
- Called when the test case *test* is about to be run.
+ :class:`TestResult` instances have the following attributes that will be of
+ interest when inspecting the results of running a set of tests:
- The default implementation simply increments the instance's ``testsRun``
- counter.
+ .. attribute:: errors
-.. method:: TestResult.stopTest(test)
+ A list containing 2-tuples of :class:`TestCase` instances and strings
+ holding formatted tracebacks. Each tuple represents a test which raised an
+ unexpected exception.
- Called after the test case *test* has been executed, regardless of the outcome.
+ .. versionchanged:: 2.2
- The default implementation does nothing.
+ Contains formatted tracebacks instead of :func:`sys.exc_info` results.
-.. method:: TestResult.addError(test, err)
+ .. attribute:: failures
- Called when the test case *test* raises an unexpected exception *err* is a tuple
- of the form returned by :func:`sys.exc_info`: ``(type, value, traceback)``.
+ A list containing 2-tuples of :class:`TestCase` instances and strings
+ holding formatted tracebacks. Each tuple represents a test where a failure
+ was explicitly signalled using the :meth:`TestCase.fail\*` or
+ :meth:`TestCase.assert\*` methods.
- The default implementation appends a tuple ``(test, formatted_err)`` to the
- instance's ``errors`` attribute, where *formatted_err* is a formatted
- traceback derived from *err*.
+ .. versionchanged:: 2.2
+ Contains formatted tracebacks instead of :func:`sys.exc_info` results.
-.. method:: TestResult.addFailure(test, err)
+ .. attribute:: skipped
- Called when the test case *test* signals a failure. *err* is a tuple of the form
- returned by :func:`sys.exc_info`: ``(type, value, traceback)``.
+ A list containing 2-tuples of :class:`TestCase` instances and strings
+ holding the reason for skipping the test.
- The default implementation appends a tuple ``(test, formatted_err)`` to the
- instance's ``failures`` attribute, where *formatted_err* is a formatted
- traceback derived from *err*.
+ .. versionadded:: 2.7
+ .. attribute:: expectedFailures
-.. method:: TestResult.addSuccess(test)
+ A list contaning 2-tuples of :class:`TestCase` instances and strings
+ holding formatted tracebacks. Each tuple represents a expected failures
+ of the test case.
- Called when the test case *test* succeeds.
+ .. attribute:: unexpectedSuccesses
- The default implementation does nothing.
+ A list containing :class:`TestCase` instances that were marked as expected
+ failures, but succeeded.
+ .. attribute:: shouldStop
-.. method:: TestResult.addSkip(test, reason)
+ Set to ``True`` when the execution of tests should stop by :meth:`stop`.
- Called when the test case *test* is skipped. *reason* is the reason the test
- gave for skipping.
- The default implementation appends a tuple ``(test, reason)`` to the
- instance's ``skipped`` attribute.
+ .. attribute:: testsRun
+ The total number of tests run so far.
-.. method:: TestResult.addExpectedFailure(test, err)
- Called when the test case *test* fails, but was marked with the
- :func:`expectedFailure` decorator.
+ .. method:: wasSuccessful()
- The default implementation appends a tuple ``(test, formatted_err)`` to the
- instance's ``expected_failures`` attribute, where *formatted_err* is a
- formatted traceback derived from *err*.
+ Return :const:`True` if all tests run so far have passed, otherwise returns
+ :const:`False`.
-.. method:: TestResult.addUnexpectedSuccess(test)
+ .. method:: stop()
- Called when the test case *test* was marked with the :func:`expectedFailure`
- decorator, but succeeded.
+ This method can be called to signal that the set of tests being run should
+ be aborted by setting the :attr:`shouldStop` attribute to :const:`True`.
+ :class:`TestRunner` objects should respect this flag and return without
+ running any additional tests.
- The default implementation appends the test to the instance's
- ``unexpected_successes`` attribute.
+ For example, this feature is used by the :class:`TextTestRunner` class to
+ stop the test framework when the user signals an interrupt from the
+ keyboard. Interactive tools which provide :class:`TestRunner`
+ implementations can use this in a similar manner.
+ The following methods of the :class:`TestResult` class are used to maintain
+ the internal data structures, and may be extended in subclasses to support
+ additional reporting requirements. This is particularly useful in building
+ tools which support interactive reporting while tests are being run.
-.. _testloader-objects:
-TestLoader Objects
-------------------
+ .. method:: startTest(test)
-The :class:`TestLoader` class is used to create test suites from classes and
-modules. Normally, there is no need to create an instance of this class; the
-:mod:`unittest` module provides an instance that can be shared as
-``unittest.defaultTestLoader``. Using a subclass or instance, however, allows
-customization of some configurable properties.
+ Called when the test case *test* is about to be run.
-:class:`TestLoader` objects have the following methods:
+ The default implementation simply increments the instance's :attr:`testsRun`
+ counter.
-.. method:: TestLoader.loadTestsFromTestCase(testCaseClass)
+ .. method:: stopTest(test)
- Return a suite of all tests cases contained in the :class:`TestCase`\ -derived
- :class:`testCaseClass`.
+ Called after the test case *test* has been executed, regardless of the
+ outcome.
+ The default implementation does nothing.
-.. method:: TestLoader.loadTestsFromModule(module)
- Return a suite of all tests cases contained in the given module. This method
- searches *module* for classes derived from :class:`TestCase` and creates an
- instance of the class for each test method defined for the class.
+ .. method:: addError(test, err)
- .. warning::
+ Called when the test case *test* raises an unexpected exception *err* is a
+ tuple of the form returned by :func:`sys.exc_info`: ``(type, value,
+ traceback)``.
- While using a hierarchy of :class:`TestCase`\ -derived classes can be convenient
- in sharing fixtures and helper functions, defining test methods on base classes
- that are not intended to be instantiated directly does not play well with this
- method. Doing so, however, can be useful when the fixtures are different and
- defined in subclasses.
+ The default implementation appends a tuple ``(test, formatted_err)`` to
+ the instance's :attr:`errors` attribute, where *formatted_err* is a
+ formatted traceback derived from *err*.
-.. method:: TestLoader.loadTestsFromName(name[, module])
+ .. method:: addFailure(test, err)
- Return a suite of all tests cases given a string specifier.
+ Called when the test case *test* signals a failure. *err* is a tuple of the form
+ returned by :func:`sys.exc_info`: ``(type, value, traceback)``.
- The specifier *name* is a "dotted name" that may resolve either to a module, a
- test case class, a test method within a test case class, a :class:`TestSuite`
- instance, or a callable object which returns a :class:`TestCase` or
- :class:`TestSuite` instance. These checks are applied in the order listed here;
- that is, a method on a possible test case class will be picked up as "a test
- method within a test case class", rather than "a callable object".
+ The default implementation appends a tuple ``(test, formatted_err)`` to
+ the instance's :attr:`failures` attribute, where *formatted_err* is a
+ formatted traceback derived from *err*.
- For example, if you have a module :mod:`SampleTests` containing a
- :class:`TestCase`\ -derived class :class:`SampleTestCase` with three test
- methods (:meth:`test_one`, :meth:`test_two`, and :meth:`test_three`), the
- specifier ``'SampleTests.SampleTestCase'`` would cause this method to return a
- suite which will run all three test methods. Using the specifier
- ``'SampleTests.SampleTestCase.test_two'`` would cause it to return a test suite
- which will run only the :meth:`test_two` test method. The specifier can refer
- to modules and packages which have not been imported; they will be imported as a
- side-effect.
- The method optionally resolves *name* relative to the given *module*.
+ .. method:: addSuccess(test)
+ Called when the test case *test* succeeds.
-.. method:: TestLoader.loadTestsFromNames(names[, module])
+ The default implementation does nothing.
- Similar to :meth:`loadTestsFromName`, but takes a sequence of names rather than
- a single name. The return value is a test suite which supports all the tests
- defined for each name.
+ .. method:: addSkip(test, reason)
-.. method:: TestLoader.getTestCaseNames(testCaseClass)
+ Called when the test case *test* is skipped. *reason* is the reason the
+ test gave for skipping.
- Return a sorted sequence of method names found within *testCaseClass*; this
- should be a subclass of :class:`TestCase`.
+ The default implementation appends a tuple ``(test, reason)`` to the
+ instance's :attr:`skipped` attribute.
-The following attributes of a :class:`TestLoader` can be configured either by
-subclassing or assignment on an instance:
+ .. method:: addExpectedFailure(test, err)
-.. attribute:: TestLoader.testMethodPrefix
+ Called when the test case *test* fails, but was marked with the
+ :func:`expectedFailure` decorator.
- String giving the prefix of method names which will be interpreted as test
- methods. The default value is ``'test'``.
+ The default implementation appends a tuple ``(test, formatted_err)`` to
+ the instance's :attr:`expectedFailures` attribute, where *formatted_err*
+ is a formatted traceback derived from *err*.
- This affects :meth:`getTestCaseNames` and all the :meth:`loadTestsFrom\*`
- methods.
+ .. method:: addUnexpectedSuccess(test)
-.. attribute:: TestLoader.sortTestMethodsUsing
+ Called when the test case *test* was marked with the
+ :func:`expectedFailure` decorator, but succeeded.
- Function to be used to compare method names when sorting them in
- :meth:`getTestCaseNames` and all the :meth:`loadTestsFrom\*`
- methods. This should be a function that takes two arguments
- ``self`` and ``other``, and returns ``-1`` if ``self`` precedes
- ``other`` in the desired ordering, ``1`` if ``other`` precedes
- ``self``, and ``0`` if ``self`` and ``other`` are equal. The
- default ordering is the built-in ordering for strings. This
- attribute can also be set to :const:`None` to disable the sort.
+ The default implementation appends the test to the instance's
+ :attr:`unexpectedSuccesses` attribute.
-.. attribute:: TestLoader.suiteClass
+.. data:: defaultTestLoader
- Callable object that constructs a test suite from a list of tests. No methods on
- the resulting object are needed. The default value is the :class:`TestSuite`
- class.
+ Instance of the :class:`TestLoader` class intended to be shared. If no
+ customization of the :class:`TestLoader` is needed, this instance can be used
+ instead of repeatedly creating new instances.
- This affects all the :meth:`loadTestsFrom\*` methods.
+.. class:: TextTestRunner([stream[, descriptions[, verbosity]]])
-.. attribute:: TestLoader.classSuiteClass
+ A basic test runner implementation which prints results on standard error. It
+ has a few configurable parameters, but is essentially very simple. Graphical
+ applications which run test suites should provide alternate implementations.
- Callable object that constructs a test suite for the tests cases from one
- class. The default value is :class:`ClassTestSuite`.
+.. function:: main([module[, defaultTest[, argv[, testRunner[, testLoader]]]]])
+
+ A command-line program that runs a set of tests; this is primarily for making
+ test modules conveniently executable. The simplest use for this function is to
+ include the following line at the end of a test script::
+
+ if __name__ == '__main__':
+ unittest.main()
+
+ The *testRunner* argument can either be a test runner class or an already
+ created instance of it.
Further information is available in the bundled documentation, and from
- http://docs.python.org/lib/module-unittest.html
+ http://docs.python.org/library/unittest.html
Copyright (c) 1999-2003 Steve Purcell
+Copyright (c) 2003-2009 Python Software Foundation
This module is free software, and you may redistribute it and/or modify
it under the same terms as Python itself, so long as this copyright message
and disclaimer are retained in their original form.
SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
'''
-__author__ = "Steve Purcell"
-__email__ = "stephen_purcell at yahoo dot com"
-__version__ = "#Revision: 1.63 $"[11:-2]
-
import time
import sys
import traceback
##############################################################################
# Exported classes and functions
##############################################################################
-__all__ = ['TestResult', 'TestCase', 'TestSuite', 'TextTestRunner',
- 'TestLoader', 'FunctionTestCase', 'main', 'defaultTestLoader']
+__all__ = ['TestResult', 'TestCase', 'TestSuite', 'ClassTestSuite',
+ 'TextTestRunner', 'TestLoader', 'FunctionTestCase', 'main',
+ 'defaultTestLoader', 'SkipException', 'skip', 'skipIf', 'skipUnless',
+ 'expectedFailure']
# Expose obsolete functions for backwards compatibility
__all__.extend(['getTestCaseNames', 'makeSuite', 'findTestCases'])
self.errors = []
self.testsRun = 0
self.skipped = []
- self.expected_failures = []
- self.unexpected_successes = []
+ self.expectedFailures = []
+ self.unexpectedSuccesses = []
self.shouldStop = False
def startTest(self, test):
def addExpectedFailure(self, test, err):
"""Called when an expected failure/error occured."""
- self.expected_failures.append(
+ self.expectedFailures.append(
(test, self._exc_info_to_string(err, test)))
def addUnexpectedSuccess(self, test):
"""Called when a test was expected to fail, but succeed."""
- self.unexpected_successes.append(test)
+ self.unexpectedSuccesses.append(test)
def wasSuccessful(self):
"Tells whether or not this result was a success"
(_strclass(self.__class__), self.testsRun, len(self.errors),
len(self.failures))
+
class AssertRaisesContext(object):
+
+
def __init__(self, expected, test_case, callable_obj=None):
self.expected = expected
self.failureException = test_case.failureException
self.obj_name = str(callable_obj)
else:
self.obj_name = None
+
def __enter__(self):
pass
+
def __exit__(self, exc_type, exc_value, traceback):
if exc_type is None:
try:
# Let unexpected exceptions skip through
return False
+
class TestCase(object):
"""A class whose instances are single test cases.
method when executed. Raises a ValueError if the instance does
not have a method with the specified name.
"""
+ self._testMethodName = methodName
try:
- self._testMethodName = methodName
testMethod = getattr(self, methodName)
- self._testMethodDoc = testMethod.__doc__
except AttributeError:
raise ValueError("no such test method in %s: %s" % \
(self.__class__, methodName))
+ self._testMethodDoc = testMethod.__doc__
def setUp(self):
"Hook method for setting up the test fixture before exercising it."
def __eq__(self, other):
if type(self) is not type(other):
- return False
+ return NotImplemented
return self._testMethodName == other._testMethodName
(_strclass(self.__class__), self._testMethodName)
def run(self, result=None):
- if result is None: result = self.defaultTestResult()
+ if result is None:
+ result = self.defaultTestResult()
result.startTest(self)
testMethod = getattr(self, self._testMethodName)
try:
def failIf(self, expr, msg=None):
"Fail the test if the expression is true."
- if expr: raise self.failureException(msg)
+ if expr:
+ raise self.failureException(msg)
def failUnless(self, expr, msg=None):
"""Fail the test unless the expression is true."""
- if not expr: raise self.failureException(msg)
+ if not expr:
+ raise self.failureException(msg)
def failUnlessRaises(self, excClass, callableObj=None, *args, **kwargs):
"""Fail unless an exception of class excClass is thrown
def __repr__(self):
return "<%s tests=%s>" % (_strclass(self.__class__), self._tests)
- __str__ = __repr__
-
def __eq__(self, other):
if not isinstance(other, self.__class__):
return NotImplemented
def debug(self):
"""Run the tests without collecting errors in a TestResult"""
- for test in self._tests: test.debug()
+ for test in self._tests:
+ test.debug()
class ClassTestSuite(TestSuite):
always be called if the set-up ('setUp') function ran successfully.
"""
- def __init__(self, testFunc, setUp=None, tearDown=None,
- description=None):
- TestCase.__init__(self)
+ def __init__(self, testFunc, setUp=None, tearDown=None, description=None):
+ super(FunctionTestCase, self).__init__()
self.__setUpFunc = setUp
self.__tearDownFunc = tearDown
self.__testFunc = testFunc
return self.__testFunc.__name__
def __eq__(self, other):
- if type(self) is not type(other):
- return False
+ if not isinstance(other, self.__class__):
+ return NotImplemented
return self.__setUpFunc == other.__setUpFunc and \
self.__tearDownFunc == other.__tearDownFunc and \
return (x > y) - (x < y)
class TestLoader(object):
- """This class is responsible for loading tests according to various
- criteria and returning them wrapped in a TestSuite
+ """
+ This class is responsible for loading tests according to various criteria
+ and returning them wrapped in a TestSuite
"""
testMethodPrefix = 'test'
sortTestMethodsUsing = staticmethod(three_way_cmp)
def loadTestsFromTestCase(self, testCaseClass):
"""Return a suite of all tests cases contained in testCaseClass"""
if issubclass(testCaseClass, TestSuite):
- raise TypeError("Test cases should not be derived from TestSuite."
- "Maybe you meant to derive from TestCase?")
+ raise TypeError("Test cases should not be derived from TestSuite." \
+ " Maybe you meant to derive from TestCase?")
testCaseNames = self.getTestCaseNames(testCaseClass)
if not testCaseNames and hasattr(testCaseClass, 'runTest'):
testCaseNames = ['runTest']
break
except ImportError:
del parts_copy[-1]
- if not parts_copy: raise
+ if not parts_copy:
+ raise
parts = parts[1:]
obj = module
for part in parts:
"""
def isTestMethod(attrname, testCaseClass=testCaseClass,
prefix=self.testMethodPrefix):
- return attrname.startswith(prefix) \
- and hasattr(getattr(testCaseClass, attrname), '__call__')
+ return attrname.startswith(prefix) and \
+ hasattr(getattr(testCaseClass, attrname), '__call__')
testFnNames = list(filter(isTestMethod, dir(testCaseClass)))
if self.sortTestMethodsUsing:
testFnNames.sort(key=CmpToKey(self.sortTestMethodsUsing))
separator2 = '-' * 70
def __init__(self, stream, descriptions, verbosity):
- TestResult.__init__(self)
+ super(_TextTestResult, self).__init__()
self.stream = stream
self.showAll = verbosity > 1
self.dots = verbosity == 1
return str(test)
def startTest(self, test):
- TestResult.startTest(self, test)
+ super(_TextTestResult, self).startTest(test)
if self.showAll:
self.stream.write(self.getDescription(test))
self.stream.write(" ... ")
self.stream.flush()
def addSuccess(self, test):
- TestResult.addSuccess(self, test)
+ super(_TextTestResult, self).addSuccess(test)
if self.showAll:
self.stream.writeln("ok")
elif self.dots:
self.stream.flush()
def addError(self, test, err):
- TestResult.addError(self, test, err)
+ super(_TextTestResult, self).addError(test, err)
if self.showAll:
self.stream.writeln("ERROR")
elif self.dots:
self.stream.flush()
def addFailure(self, test, err):
- TestResult.addFailure(self, test, err)
+ super(_TextTestResult, self).addFailure(test, err)
if self.showAll:
self.stream.writeln("FAIL")
elif self.dots:
self.stream.flush()
def addSkip(self, test, reason):
- TestResult.addSkip(self, test, reason)
+ super(_TextTestResult, self).addSkip(test, reason)
if self.showAll:
self.stream.writeln("skipped {0!r}".format(reason))
elif self.dots:
self.stream.flush()
def addExpectedFailure(self, test, err):
- TestResult.addExpectedFailure(self, test, err)
+ super(_TextTestResult, self).addExpectedFailure(test, err)
if self.showAll:
self.stream.writeln("expected failure")
elif self.dots:
self.stream.flush()
def addUnexpectedSuccess(self, test):
- TestResult.addUnexpectedSuccess(self, test)
+ super(_TextTestResult, self).addUnexpectedSuccess(test)
if self.showAll:
self.stream.writeln("unexpected success")
elif self.dots:
self.stream.writeln("Ran %d test%s in %.3fs" %
(run, run != 1 and "s" or "", timeTaken))
self.stream.writeln()
- results = map(len, (result.expected_failures,
- result.unexpected_successes,
+ results = map(len, (result.expectedFailures,
+ result.unexpectedSuccesses,
result.skipped))
- expected_fails, unexpected_successes, skipped = results
+ expectedFails, unexpectedSuccesses, skipped = results
infos = []
if not result.wasSuccessful():
self.stream.write("FAILED")
if errored:
infos.append("errors=%d" % errored)
else:
- self.stream.write("OK")
+ self.stream.writeln("OK")
if skipped:
infos.append("skipped=%d" % skipped)
- if expected_fails:
- infos.append("expected failures=%d" % expected_fails)
- if unexpected_successes:
- infos.append("unexpected successes=%d" % unexpected_successes)
+ if expectedFails:
+ infos.append("expected failures=%d" % expectedFails)
+ if unexpectedSuccesses:
+ infos.append("unexpected successes=%d" % unexpectedSuccesses)
if infos:
self.stream.writeln(" (%s)" % (", ".join(infos),))
return result
self.runTests()
def usageExit(self, msg=None):
- if msg: print(msg)
+ if msg:
+ print(msg)
print(self.USAGE % self.__dict__)
sys.exit(2)
projects / python / commitdiff