Right now, in Python there is no way to do parametrized testing. Well, actually there are many ways. Python is an extremely flexible and high level languange and adding that features is a matter of less than a hundred lines of code (or somewhat more, perhaps, if you want an even richer semantics). Just the bare bone functionality may take just a dozen lines of code.
For this reason, many people implemented their own version (see the linked thread). Plus there are nose and py.test variants. Actually, I have used nose to perform that kind of tests.
Nose allows tests to be simple functions (and uses python decorators to add setUp and tearDown functions when necessary).This is a (buggy) quicksort implementation in Python:
def quicksort(lst, select_pivot=lambda s, e: s + (s-e)/2): def partition(start, end): pivot = select_pivot(start, end) lst[pivot], lst[start] = lst[start], lst[pivot] left = start right = end + 1 pivot_element = lst[pivot] while 1: left += 1 right -= 1 while (left <= end) and (lst[left] < pivot_element): left += 1 while lst[right] > pivot_element: right -= 1 if left > right: break lst[left], lst[right] = lst[right], lst[left] lst[start], lst[right] = lst[right], lst[start] return right def sort(start, end): if start >= end: return pivot = partition(start, end) sort(start, pivot-1) sort(pivot+1, start) sort(0, len(lst)-1)
And this is the test:
import qsort from nose import tools fixture_lsts = [ [1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 3, 2, 3], [4, 2, 3, 1], [1, 4, 3, 2], [3, 2, 1, 4], [3, 2, 2, 4], [3, 1, 1, 3], [1, 1, 1, 1], [1, 2, 1, 1], [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1], [3, 2, 3], [3, 1, 1], ,  ] def check_sorted(lst): sorted_lst = sorted(lst) lst = lst[:] # do not modify lists qsort.quicksort(lst) tools.assert_equals(lst, sorted_lst) def test_quicksort(): for lst in fixture_lsts: yield check_sorted, lst
This is what I see from WingIDE:
|Buggy quicksort test output|
In fact, the test function is allowed to be a generator. In this case, it is assumed to yield tuples where the first argument is a callable and the others are its parameters. This way it is very easy to do parametrized testing.
Please notice (the documentation points that out) that if you attach setup and teardown stuff to the test function then they will be run just once, before and after the whole test function and not before and after every parametrized test. This is what I usually would like, in fact. In order to have this behavior, it is sufficient to add the functions to the yielded callable.
For example, I see that in the proposed "check" function we are doing stuff which should be done in a setup method. Unfortunately one of my greatest dissatisfactions with nose (and with_setup in particular) is that it completely forces you to use a stateful model.
From the setup function to the executed test function the only way to communicate is through the global environment. This is half bad (I've not yet decided if I prefer the overkill of TestCase classes -- where classes are just used for grouping purposes without "true" object behavior from the user point of view -- or using module variables -- which seems very pythonic as modules are objects but somewhat encourages the use of global variables).
This works quite well if you model all your tests with this idea in mind (and basically it's not different from xUnit model, just no classes). Unfortunately when you use generator based testing the test function receives the part of the SUT to test as a parameter, and the parameter is not accessible from the setup function. The easiest solution (the one which does not involve writing some custom test loader or at least a new piece of code at nose level), is useing classes.
In fact, the yielded callable is allowed to be a callable object. In this case, it is possible to define a setup function "as if" it were a TestCase (still, it is not a TestCase.
The resulting code is:
class CheckSorted(object): def __init__(self, lst): self.lst = lst def setup(self): self.sorted_lst = sorted(self.lst) self.lst = self.lst[:] def __call__(self): qsort.quicksort(self.lst) tools.assert_equals(self.lst, self.sorted_lst) def test_quicksort2(): for lst in fixture_lsts: yield CheckSorted(lst),
Please notice the , (comma) at the end of the yield statement. It is necessaty as a tuple must be yielded. Of course code could be made more explicit with
yield (CheckSorted(lst), )
I don't actually like this solution very much, since it is somewhat confusing what the costructor should do: usually TestCases do not have a constructor. Setup methods just set them up. However, in this case, part of the job is performed by the constructor (and there is no other way -- unless we use a global or something like that, but I believe the cure is worse than the illness). Anyway, this is what we have.