summaryrefslogtreecommitdiffstats
path: root/Doc/library/unittest.rst
diff options
context:
space:
mode:
authorEzio Melotti <ezio.melotti@gmail.com>2015-03-24 10:42:41 (GMT)
committerEzio Melotti <ezio.melotti@gmail.com>2015-03-24 10:42:41 (GMT)
commit2e3998fae0996bbb349a4696071f0582f8c799c0 (patch)
tree78addf6cb487c41057bac000d824b01610e6b3cd /Doc/library/unittest.rst
parent19276f184f00829ce55ce0e98f8db06d93b7d665 (diff)
downloadcpython-2e3998fae0996bbb349a4696071f0582f8c799c0.zip
cpython-2e3998fae0996bbb349a4696071f0582f8c799c0.tar.gz
cpython-2e3998fae0996bbb349a4696071f0582f8c799c0.tar.bz2
#11468: improve unittest basic example. Initial patch by Florian Preinstorfer.
Diffstat (limited to 'Doc/library/unittest.rst')
-rw-r--r--Doc/library/unittest.rst65
1 files changed, 28 insertions, 37 deletions
diff --git a/Doc/library/unittest.rst b/Doc/library/unittest.rst
index c65a99d..bdb18bc 100644
--- a/Doc/library/unittest.rst
+++ b/Doc/library/unittest.rst
@@ -80,37 +80,29 @@ The :mod:`unittest` module provides a rich set of tools for constructing and
running tests. This section demonstrates that a small subset of the tools
suffice to meet the needs of most users.
-Here is a short script to test three functions from the :mod:`random` module::
+Here is a short script to test three string methods::
- import random
- import unittest
-
- class TestSequenceFunctions(unittest.TestCase):
+ import unittest
- def setUp(self):
- self.seq = list(range(10))
+ class TestStringMethods(unittest.TestCase):
- 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, list(range(10)))
+ def test_upper(self):
+ self.assertEqual('foo'.upper(), 'FOO')
- # should raise an exception for an immutable sequence
- self.assertRaises(TypeError, random.shuffle, (1,2,3))
+ def test_isupper(self):
+ self.assertTrue('FOO'.isupper())
+ self.assertFalse('Foo'.isupper())
- def test_choice(self):
- element = random.choice(self.seq)
- self.assertTrue(element in self.seq)
+ def test_split(self):
+ s = 'hello world'
+ self.assertEqual(s.split(), ['hello', 'world'])
+ # check that s.split fails when the separator is not a string
+ with self.assertRaises(TypeError):
+ s.split(2)
- def test_sample(self):
- with self.assertRaises(ValueError):
- random.sample(self.seq, 20)
- for element in random.sample(self.seq, 5):
- self.assertTrue(element in self.seq)
+ if __name__ == '__main__':
+ unittest.main()
- if __name__ == '__main__':
- unittest.main()
A testcase is created by subclassing :class:`unittest.TestCase`. The three
individual tests are defined with methods whose names start with the letters
@@ -118,16 +110,15 @@ individual tests are defined with methods whose names start with the letters
represent tests.
The crux of each test is a call to :meth:`~TestCase.assertEqual` to check for an
-expected result; :meth:`~TestCase.assertTrue` 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.
+expected result; :meth:`~TestCase.assertTrue` or :meth:`~TestCase.assertFalse`
+to verify a condition; or :meth:`~TestCase.assertRaises` to verify that a
+specific 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:`~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 :meth:`~TestCase.setUp` and :meth:`~TestCase.tearDown` methods allow you
+to define instructions that will be executed before and after each test method.
+They are covered in more details in the section :ref:`organizing-tests`.
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
@@ -142,12 +133,12 @@ line, the above script produces an output that looks like this::
Passing the ``-v`` option to your test script will instruct :func:`unittest.main`
to enable a higher level of verbosity, and produce the following output::
- test_choice (__main__.TestSequenceFunctions) ... ok
- test_sample (__main__.TestSequenceFunctions) ... ok
- test_shuffle (__main__.TestSequenceFunctions) ... ok
+ test_isupper (__main__.TestStringMethods) ... ok
+ test_split (__main__.TestStringMethods) ... ok
+ test_upper (__main__.TestStringMethods) ... ok
----------------------------------------------------------------------
- Ran 3 tests in 0.110s
+ Ran 3 tests in 0.001s
OK