Testing in Python: doctest and unittest

Testing in Python
Fariz Darari
fariz@cs.ui.ac.id

Testing vs Debugging
Testing:
Checking whether our program works for a set of inputs.
Debugging:
Finding a bug in our program and fixing it.

Software Tester as a job (1/2)

Software Tester as a job (2/2)

Why testing?
• Because your program is not perfect.
• That is, because you (as a programmer) are not perfect.
• Even a professional programmer sometimes writes a program that
still contains bugs.
• Don't use this as an excuse for you to write a program carelessly!!!
• Testing can detect bugs earlier so your program won't be released
to public with too many noticeable bugs!
• However, your program passing some testing does not mean that
your program is correct in general, it's just that your program is
correct for the given test cases!
• Still, tested code is much better than untested code!

Square area function (oops!)
def square_area(x):
return x**3

Square area function (oops!)
def square_area(x):
return x**3
Let's test this code!

You test the function, manually
>>> square_area(1)
1
So far so good, but...

You test the function, manually
>>> square_area(1)
1
So far so good, but...
>>> square_area(2)
8
The expected output is 4.
So, your program is incorrect when input = 2.

Then you fix your function
def square_area(x):
return x**2

And you test again the function, manually
>>> square_area(1)
1
So far so good...
>>> square_area(2)
4
This was previously incorrect. Now we get it correct!

And you test again the function, manually
>>> square_area(1)
1
So far so good...
>>> square_area(2)
4
This was previously incorrect. Now we get it correct!
But what about for other inputs (say when input is negative)?

Systematic ways of testing
•doctest
•unittest

doctest
• Comes prepackaged with Python
• Simple, you basically just have to include your test
cases inside your function comment (= docstring)
• from python.org:
The doctest module searches for pieces of text that
look like interactive Python sessions, and then
executes those sessions to verify that they work
exactly as shown.

Square area (oops) with doctest
import doctest
def square_area(x):
"""
compute the area of a square
>>> square_area(1)
1
>>> square_area(2)
4
"""
return x**3
if __name__ == "__main__":
doctest.testmod()

Square area (oops) with doctest

Square area with doctest
import doctest
def square_area(x):
"""
>>> square_area(1)
1
>>> square_area(2)
4
"""
return x**2
if __name__ == "__main__":
doctest.testmod()

When there is no error, there is nothing to print!

When there is no error, there is nothing to print!
Exercise:
(1) Add a testcase for negative inputs, which should return nothing
(2) Fix the square area function to handle negative inputs

import doctest
def square_area(x):
"""
>>> square_area(1)
1
>>> square_area(2)
4
>>> square_area(-1)
"""
if x < 0:
return None
return x**2
if __name__ == "__main__":
doctest.testmod()

Exercise: Create a program and doctest to
compute the area of a rectangle

import doctest
def rectangle_area(x,y):
"""
>>> rectangle_area(1,1)
1
6
>>> rectangle_area(-2,3)
>>> rectangle_area(2,-3)
20000
"""
if x < 0 or y < 0:
return None
return x*y
if __name__ == "__main__":
doctest.testmod()
Exercise: Create a program and doctest to

unittest
• Comes prepackaged with Python
• More extensive than doctest, you have to write
your own, separate, testing code
• As the name suggests, unit testing tests units or
components of the code. (= imagine that your code is
millions of lines, and you have to test it)

unittest for String methods
import unittest
class TestStringMethods(unittest.TestCase):
def test_upper(self):
self.assertEqual('foo'.upper(), 'FOO')
def test_isupper(self):
self.assertTrue('FOO'.isupper())
self.assertFalse('Foo'.isupper())
def test_split(self):
s = 'hello world'
self.assertEqual(s.split(), ['hello', 'world'])
if __name__ == '__main__':
unittest.main()

Square area (oops) with unittest
def square_area(x):
return x**3
square_oops.py
import unittest
from square_oops import square_area
class TestSquareArea(unittest.TestCase):
def test_negative(self):
self.assertEqual(square_area(-1), None)
def test_positive(self):
self.assertEqual(square_area(1),1)
def test_positive_large(self):
if __name__ == '__main__':
unittest.main()
square_oops_test.py

Square area with unittest
def square_area(x):
if x < 0: return None
return x**2
square.py
import unittest
from square import square_area
class TestSquareArea(unittest.TestCase):
self.assertEqual(square_area(-1), None)
if __name__ == '__main__':
unittest.main()
square_test.py

Exercise: Create a program and unittest to

Rectangle area with unittest
def rectangle_area(x,y):
if x < 0 or y < 0: return None
return x*y
rectangle.py
import unittest
from rectangle import rectangle_area
class TestRectangleArea(unittest.TestCase):
self.assertEqual(rectangle_area(-1,1), None)
self.assertEqual(rectangle_area(1,-1), None)
self.assertEqual(rectangle_area(-1,-1), None)
self.assertEqual(rectangle_area(1,1),1)
if __name__ == '__main__':
unittest.main()
rectangle_test.py
(you need to copy and paste the code!)

Test-Driven Development (TDD)
• A method of software development to define tests
before actually starting coding!
• The tests define the desired behavior of the program.
• In this way, you code with the mission to satisfy the
tests!

TDD Stages
1. Before writing any code, write test cases.
2. Run the tests, this would surely fail since there is no
code yet.
3. Make working code as minimum as possible to satisfy
the tests.
4. Run the tests, and check if your code passes. If not, fix
your code until you pass.
5. Now, time to refactor (= clean) your code, make sure the
refactored code passes the tests.
6. Repeat 1-5 for other program features.

Testing in Python: doctest and unittest

More Related Content

What's hot (19)

Similar to Testing in Python: doctest and unittest (20)

More from Fariz Darari (20)

Recently uploaded (20)

Testing in Python: doctest and unittest

Editor's Notes