Declares a test function that a test runner will execute to verify that an addition operation returns the expected value.

Declares a test assertion that the sum of x and y equals expected, enabling automated verification of addition logic.

When writing unit tests for an addition function, during test‑driven development, or when verifying correctness of arithmetic operations in code.

Unit testing suites, test‑driven development workflows, educational examples of testing, continuous integration test suites.

def test_<name>(param1, param2, expected):

def test_add(x, y, expected):

function_name: identifier (e.g., test_add), param1: identifier (e.g., x), param2: identifier (e.g., y), expected: identifier (e.g., expected)

• assert
• assertEqual
• pytest
• unittest
• test case
• test suite

• different test names (e.g.
• test_subtract
• test_multiply)
• different parameter names (e.g.
• a
• b
• expected)
• using pytest’s plain assert instead of unittest’s assertEqual

1. Forgetting to include an assertion statement (cause: assuming the test passes by default) → consequence: test passes regardless of function output, missing bugs. 2. Using the wrong assertion method (e.g., assertEqual for floating‑point values) → consequence: false failures due to precision issues. 3. Omitting or misordering the expected parameter (cause: copy‑paste error) → consequence: test compares wrong values, leading to false positives/negatives. 4. Using a reserved word as a parameter name (cause: syntax error) → consequence: syntax error preventing test collection. 5. Forgetting to import the function under test (cause: oversight) → consequence: NameError when the test runs.

test_subtract – tests subtraction instead of addition; property‑based test – generates many random inputs instead of fixed examples; fixture‑based test – uses setup/teardown fixtures for shared state; doctest – embeds tests in docstrings rather than separate functions.

Coming from Java’s JUnit: may forget to call assertEquals and rely on a return value → correction: use assertEqual to compare expected and actual. Coming from JavaScript’s informal testing: may use console.log to inspect output → correction: use proper assertions so the test framework can report pass/fail.

• unit testing patterns
• test fixtures
• parametrized tests

Not suitable for testing complex objects where deep equality is needed; performance impact is negligible as the test itself is trivial; boundary cases such as integer overflow, NaN, or extreme values require additional specialized tests.

Ensures the addition function behaves correctly for the given inputs, catches regressions early, and serves as executable documentation of the function’s contract.

Think of a test case as a contract: you promise that given these inputs, the function will return exactly this output, and the test harness checks that promise.

This pattern is a basic unit‑test template; more advanced testing may use parametrization, fixtures, or property‑based testing.

Move to parameterized tests or property‑based testing to cover many cases with a single template.