How can I test several cases for the same function without duplicating test logic?

Store the cases as data, then run the same assertion for each one in a loop. With unittest, put self.subTest(...) around the assertion. A subtest can identify the iteration by displaying its supplied message or parameters when it fails [S1].

For example, suppose the function should report whether a number is even. The case names below are descriptive labels, not special unittest syntax:

import unittest


def is_even(number):
    return number % 2 == 0


class IsEvenTests(unittest.TestCase):
    def test_examples(self):
        cases = [
            ("negative even", -4, True),
            ("zero", 0, True),
            ("positive odd", 3, False),
        ]

        for name, value, expected in cases:
            with self.subTest(case=name, value=value):
                self.assertEqual(is_even(value), expected)


if __name__ == "__main__":
    unittest.main()

There is one assertion to maintain, while the inputs and expected results stay visible as a short list.

Name the condition the example is meant to represent, and include a relevant input as a subtest parameter when that helps distinguish cases. For instance, case="negative even" communicates more than case="case 1"; value=-4 makes the input explicit too.

Keep labels short and specific: empty input, one item, or mixed case are more useful than edge case. If two examples have the same label, add a distinguishing value or another parameter. The goal is to make the failing iteration recognizable without having to count its position in the list.

Use the loop for cases that share the same basic check: provide inputs and compare the result with an expected value. If a scenario needs a different kind of assertion or setup, a separate test method can make its purpose clearer. Avoid turning the case list into a complicated mini-framework.

For a function with two inputs, add both to each case tuple and pass both into the function. For example, a case could be ("small addition", 2, 3, 5), unpacked as name, left, right, expected; then call add(left, right) inside the subtest. Keep the names and values aligned so each row is easy to inspect.

Put the cases near the test that uses them, choose names that describe the behavior, and keep each row in the same order: label, inputs, expected result. When adding a case, check that its expected result reflects the behavior you intend to test rather than simply copying the function’s current output.

A subtest helps identify a failed iteration; it does not establish that your chosen examples cover every behavior or prove the function is correct. Subtests display supplied messages or parameters when an iteration fails [S1]. Choose the cases based on the function’s intended behavior.