In this video, we'll explore how to test a function that mutates a parameter.
We'll start with a doctest example, and then we'll translate it to unittest.
Here is a function that removes items from one list that appear in another list.
The algorithm is straightforward for each item in the second list.
If that item appears in the first list, remove it.
In the doctest, we create two lists. We have intentionally not used l1 and l2
as variable names in order to remind everyone that parameters are local
variables, and we can use any name we like for the two lists outside of the function.
Now, we call function RemoveShared. The function has no return statement.
It produces none. This means that when we call the function
there is no useful return value to examine in our test.
Instead, we examine list 1 and then list 2.
We want to make sure that list 1 has been mutated properly, and we want to make sure
that list 2 has not been mutated. For thorough testing, it's important to
check this. If you pass a mutable value to a function
that isn't supposed to mutate that value, make sure to check that it hasn't been
mutated. Let's write the unittest version.
Every unittest starts out by importing unittest as well as the, the module
containing the functions that we're testing.
We need a subclass of test case. We'll name it based on the function we're
testing. And we'll write a brief doc string for our
new class. We'll write only one method, because there
is only one call on function the move shared in the dot test.
Remember that every unit has test method, has to start with the letters, test,
because our test involves two lists where there are some shared items and some
non-shared items. We'll choose test_general_case for our
name. The doc string should describe the test.
Remember that if the test fails, then this doc string is part of the output, so try
to make it clear and helpful. Now, let's write the actual testing code.
We'll Copy and Paste from the doctest to initialize our two lists.
Once we call RemoveShared, we expect the lists to look like this.
We need to call function remove_shared, and then we need to assert that the two
lists are equal to what we expected. And now, with variable underscores name
refers to the string underscores main, then we'll run our unittests.
Let's see how we did. We'll run our doctests.
Notice that there's no output. That's a good thing.
And now, we'll run our unittest. The single dot indicates that our only
test method passed. And that's how you test a function that
mutates a parameter. If you wanted to thoroughly test function
RemoveShared, you would have to decide what your tests should be and then write
one test method for each test you came up with.
We'll leave that, as a practice exercise.
Jennifer CampbellAssociate Professor, Teaching Stream
Paul GriesAssociate Professor, Teaching Stream
