Skip to content

C
cpython
Commit 52baa290 authored by Benjamin Peterson's avatar Benjamin Peterson
Browse files
Options

Merged revisions 70558,70561-70563,70568-70571 via svnmerge from 

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r70558 | benjamin.peterson | 2009-03-23 17:29:45 -0500 (Mon, 23 Mar 2009) | 4 lines

  comply with the evilJavaNamingScheme for attribute names

  It seems my love of PEP 8 overrode the need for consistentcy
........
  r70561 | benjamin.peterson | 2009-03-23 18:10:14 -0500 (Mon, 23 Mar 2009) | 1 line

  refactor unittest docs
........
  r70562 | benjamin.peterson | 2009-03-23 18:13:36 -0500 (Mon, 23 Mar 2009) | 1 line

  forgot to document that setUp can be skipped (silly me...)
........
  r70563 | benjamin.peterson | 2009-03-23 18:19:03 -0500 (Mon, 23 Mar 2009) | 1 line

  update from CVS
........
  r70568 | benjamin.peterson | 2009-03-23 19:35:20 -0500 (Mon, 23 Mar 2009) | 1 line

  some cleanup and modernization
........
  r70569 | benjamin.peterson | 2009-03-23 19:36:16 -0500 (Mon, 23 Mar 2009) | 1 line

  remove special metadata
........
  r70570 | benjamin.peterson | 2009-03-23 19:37:12 -0500 (Mon, 23 Mar 2009) | 1 line

  update docstring
........
  r70571 | benjamin.peterson | 2009-03-23 19:39:24 -0500 (Mon, 23 Mar 2009) | 1 line

  add new skipping things to __all__
........
parent 6b232cdc
Show whitespace changes
Inline Side-by-side
Showing with 477 additions and 438 deletions
Doc/library/unittest.rst
View file @ 52baa290
......@@ -11,8 +11,7 @@
.. 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
......@@ -51,27 +50,28 @@ The test case and test fixture concepts are supported through the
: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::
......@@ -109,17 +109,17 @@ Here is a short script to test three functions from the :mod:`random` module::
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)
......@@ -132,16 +132,17 @@ 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
......@@ -196,8 +197,8 @@ The testing code of a :class:`TestCase` instance should be entirely self
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
......@@ -226,8 +227,8 @@ the above case, constructing a :class:`Widget` in each of 100 Widget test case
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
......@@ -246,12 +247,12 @@ we run the test::
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
......@@ -263,8 +264,8 @@ Similarly, we can provide a :meth:`tearDown` method that tidies up after the
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`.
......@@ -293,11 +294,12 @@ mechanism::
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')
......@@ -417,6 +419,11 @@ may treat :exc:`AssertionError` differently.
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:
......@@ -453,6 +460,9 @@ Classes can be skipped just like methods: ::
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):
......@@ -495,6 +505,13 @@ The following decorators implement test skipping and expected failures:
Classes and functions
---------------------
This section describes in depth the API of :mod:`unittest`.
.. _testcase-objects:
Test cases
~~~~~~~~~~
.. class:: TestCase([methodName])
......@@ -518,554 +535,567 @@ Classes and functions
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)
TestSuite Objects
-----------------
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.
: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
~~~~~~~~~~~~~~~~~~~~~~~~~
.. method:: TestSuite.addTest(test)
.. class:: TestLoader()
Add a :class:`TestCase` or :class:`TestSuite` to the suite.
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.
:class:`TestLoader` objects have the following methods:
.. method:: TestSuite.addTests(tests)
Add all the tests from an iterable of :class:`TestCase` and :class:`TestSuite`
instances to this test suite.
.. method:: loadTestsFromTestCase(testCaseClass)
This is equivalent to iterating over *tests*, calling :meth:`addTest` for each
element.
Return a suite of all tests cases contained in the :class:`TestCase`\ -derived
:class:`testCaseClass`.
:class:`TestSuite` shares the following methods with :class:`TestCase`:
.. method:: loadTestsFromModule(module)
.. method:: TestSuite.run(result)
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.
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.
.. warning::
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()
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.
.. method:: loadTestsFromName(name[, module])
Return a suite of all tests cases given a string specifier.
.. method:: TestSuite.countTestCases()
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".
Return the number of tests represented by this test object, including all
individual tests and sub-suites.
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.
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.
The method optionally resolves *name* relative to the given *module*.
.. _testresult-objects:
.. 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.
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.
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.
.. method:: getTestCaseNames(testCaseClass)
:class:`TestResult` instances have the following attributes that will be of
interest when inspecting the results of running a set of tests:
Return a sorted sequence of method names found within *testCaseClass*;
this should be a subclass of :class:`TestCase`.
The following attributes of a :class:`TestLoader` can be configured either by
subclassing or assignment on an instance:
.. attribute:: TestResult.errors
A list containing 2-tuples of :class:`TestCase` instances and strings holding
formatted tracebacks. Each tuple represents a test which raised an unexpected
exception.
.. attribute:: testMethodPrefix
String giving the prefix of method names which will be interpreted as test
methods. The default value is ``'test'``.
.. attribute:: TestResult.failures
This affects :meth:`getTestCaseNames` and all the :meth:`loadTestsFrom\*`
methods.
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
.. attribute:: TestResult.testsRun
Function to be used to compare method names when sorting them in
:meth:`getTestCaseNames` and all the :meth:`loadTestsFrom\*` methods.
The total number of tests run so far.
.. attribute:: suiteClass
.. method:: TestResult.wasSuccessful()
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.
Returns :const:`True` if all tests run so far have passed, otherwise returns
:const:`False`.
This affects all the :meth:`loadTestsFrom\*` methods.
.. method:: TestResult.stop()
.. attribute:: classSuiteClass
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.
Callable object that constructs a test suite for the tests cases from one
class. The default value is :class:`ClassTestSuite`.
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.
.. class:: TestResult
This class is used to compile information about which tests have succeeded
and which have failed.
.. method:: TestResult.startTest(test)
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.
Called when the test case *test* is about to be run.
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.
The default implementation simply increments the instance's ``testsRun``
counter.
:class:`TestResult` instances have the following attributes that will be of
interest when inspecting the results of running a set of tests:
.. method:: TestResult.stopTest(test)
.. attribute:: errors
Called after the test case *test* has been executed, regardless of the outcome.
A list containing 2-tuples of :class:`TestCase` instances and strings
holding formatted tracebacks. Each tuple represents a test which raised an
unexpected exception.
The default implementation does nothing.
.. versionchanged:: 2.2
Contains formatted tracebacks instead of :func:`sys.exc_info` results.
.. method:: TestResult.addError(test, err)
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)``.
.. attribute:: failures
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*.
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.
.. versionchanged:: 2.2
.. method:: TestResult.addFailure(test, err)
Contains formatted tracebacks instead of :func:`sys.exc_info` results.
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)``.
.. attribute:: skipped
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*.
A list containing 2-tuples of :class:`TestCase` instances and strings
holding the reason for skipping the test.
.. versionadded:: 2.7
.. method:: TestResult.addSuccess(test)
.. attribute:: expectedFailures
Called when the test case *test* succeeds.
A list contaning 2-tuples of :class:`TestCase` instances and strings
holding formatted tracebacks. Each tuple represents a expected failures
of the test case.
The default implementation does nothing.
.. attribute:: unexpectedSuccesses
A list containing :class:`TestCase` instances that were marked as expected
failures, but succeeded.
.. method:: TestResult.addSkip(test, reason)
.. attribute:: shouldStop
Called when the test case *test* is skipped. *reason* is the reason the test
gave for skipping.
Set to ``True`` when the execution of tests should stop by :meth:`stop`.
The default implementation appends a tuple ``(test, reason)`` to the
instance's ``skipped`` attribute.
.. attribute:: testsRun
.. method:: TestResult.addExpectedFailure(test, err)
The total number of tests run so far.
Called when the test case *test* fails, but was marked with the
:func:`expectedFailure` decorator.
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*.
.. method:: wasSuccessful()
Return :const:`True` if all tests run so far have passed, otherwise returns
:const:`False`.
.. method:: TestResult.addUnexpectedSuccess(test)
Called when the test case *test* was marked with the :func:`expectedFailure`
decorator, but succeeded.
.. method:: stop()
The default implementation appends the test to the instance's
``unexpected_successes`` attribute.
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.
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.
.. _testloader-objects:
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
------------------
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.
.. method:: startTest(test)
:class:`TestLoader` objects have the following methods:
Called when the test case *test* is about to be run.
The default implementation simply increments the instance's :attr:`testsRun`
counter.
.. method:: TestLoader.loadTestsFromTestCase(testCaseClass)
Return a suite of all tests cases contained in the :class:`TestCase`\ -derived
:class:`testCaseClass`.
.. method:: stopTest(test)
Called after the test case *test* has been executed, regardless of the
outcome.
.. method:: TestLoader.loadTestsFromModule(module)
The default implementation does nothing.
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.
.. warning::
.. method:: addError(test, err)
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.
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)``.
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])
Return a suite of all tests cases given a string specifier.
.. method:: addFailure(test, err)
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".
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)``.
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 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*.
The method optionally resolves *name* relative to the given *module*.
.. method:: addSuccess(test)
.. method:: TestLoader.loadTestsFromNames(names[, module])
Called when the test case *test* succeeds.
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.
The default implementation does nothing.
.. method:: TestLoader.getTestCaseNames(testCaseClass)
.. method:: addSkip(test, reason)
Return a sorted sequence of method names found within *testCaseClass*; this
should be a subclass of :class:`TestCase`.
Called when the test case *test* is skipped. *reason* is the reason the
test gave for skipping.
The following attributes of a :class:`TestLoader` can be configured either by
subclassing or assignment on an instance:
The default implementation appends a tuple ``(test, reason)`` to the
instance's :attr:`skipped` attribute.
.. attribute:: TestLoader.testMethodPrefix
.. method:: addExpectedFailure(test, err)
String giving the prefix of method names which will be interpreted as test
methods. The default value is ``'test'``.
Called when the test case *test* fails, but was marked with the
:func:`expectedFailure` decorator.
This affects :meth:`getTestCaseNames` and all the :meth:`loadTestsFrom\*`
methods.
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*.
.. attribute:: TestLoader.sortTestMethodsUsing
.. method:: addUnexpectedSuccess(test)
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.
Called when the test case *test* was marked with the
:func:`expectedFailure` decorator, but succeeded.
The default implementation appends the test to the instance's
:attr:`unexpectedSuccesses` attribute.
.. attribute:: TestLoader.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.
.. data:: defaultTestLoader
This affects all the :meth:`loadTestsFrom\*` methods.
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.
.. attribute:: TestLoader.classSuiteClass
.. class:: TextTestRunner([stream[, descriptions[, verbosity]]])
Callable object that constructs a test suite for the tests cases from one
class. The default value is :class:`ClassTestSuite`.
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.
.. 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.
Lib/test/test_unittest.py
View file @ 52baa290
......@@ -2372,7 +2372,7 @@ class Test_TestSkipping(TestCase):
test.run(result)
self.assertEqual(events,
['startTest', 'addExpectedFailure', 'stopTest'])
self.assertEqual(result.expected_failures[0][0], test)
self.assertEqual(result.expectedFailures[0][0], test)
self.assertTrue(result.wasSuccessful())
def test_unexpected_success(self):
......@@ -2387,7 +2387,7 @@ class Test_TestSkipping(TestCase):
self.assertEqual(events,
['startTest', 'addUnexpectedSuccess', 'stopTest'])
self.assertFalse(result.failures)
self.assertEqual(result.unexpected_successes, [test])
self.assertEqual(result.unexpectedSuccesses, [test])
self.assertTrue(result.wasSuccessful())
......
Lib/unittest.py
View file @ 52baa290
......@@ -25,9 +25,10 @@ Simple usage:
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.
......@@ -44,10 +45,6 @@ AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
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
......@@ -58,8 +55,10 @@ import functools
##############################################################################
# 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'])
......@@ -163,8 +162,8 @@ class TestResult(object):
self.errors = []
self.testsRun = 0
self.skipped = []
self.expected_failures = []
self.unexpected_successes = []
self.expectedFailures = []
self.unexpectedSuccesses = []
self.shouldStop = False
def startTest(self, test):
......@@ -196,12 +195,12 @@ class TestResult(object):
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"
......@@ -239,7 +238,10 @@ class TestResult(object):
(_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
......@@ -250,8 +252,10 @@ class AssertRaisesContext(object):
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:
......@@ -269,6 +273,7 @@ class AssertRaisesContext(object):
# Let unexpected exceptions skip through
return False
class TestCase(object):
"""A class whose instances are single test cases.
......@@ -302,13 +307,13 @@ class TestCase(object):
method when executed. Raises a ValueError if the instance does
not have a method with the specified name.
"""
try:
self._testMethodName = methodName
try:
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."
......@@ -339,7 +344,7 @@ class TestCase(object):
def __eq__(self, other):
if type(self) is not type(other):
return False
return NotImplemented
return self._testMethodName == other._testMethodName
......@@ -357,7 +362,8 @@ class TestCase(object):
(_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:
......@@ -422,11 +428,13 @@ class TestCase(object):
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
......@@ -520,8 +528,6 @@ class TestSuite(object):
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
......@@ -566,7 +572,8 @@ class TestSuite(object):
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):
......@@ -609,9 +616,8 @@ class FunctionTestCase(TestCase):
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
......@@ -632,8 +638,8 @@ class FunctionTestCase(TestCase):
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 \
......@@ -680,8 +686,9 @@ def three_way_cmp(x, y):
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)
......@@ -691,8 +698,8 @@ class TestLoader(object):
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']
......@@ -727,7 +734,8 @@ class TestLoader(object):
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:
......@@ -772,8 +780,8 @@ class TestLoader(object):
"""
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))
......@@ -835,7 +843,7 @@ class _TextTestResult(TestResult):
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
......@@ -848,14 +856,14 @@ class _TextTestResult(TestResult):
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:
......@@ -863,7 +871,7 @@ class _TextTestResult(TestResult):
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:
......@@ -871,7 +879,7 @@ class _TextTestResult(TestResult):
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:
......@@ -879,7 +887,7 @@ class _TextTestResult(TestResult):
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:
......@@ -887,7 +895,7 @@ class _TextTestResult(TestResult):
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:
......@@ -895,7 +903,7 @@ class _TextTestResult(TestResult):
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:
......@@ -943,10 +951,10 @@ class TextTestRunner(object):
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")
......@@ -956,13 +964,13 @@ class TextTestRunner(object):
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
......@@ -1012,7 +1020,8 @@ Examples:
self.runTests()
def usageExit(self, msg=None):
if msg: print(msg)
if msg:
print(msg)
print(self.USAGE % self.__dict__)
sys.exit(2)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7