To verify that the addition function behaves as expected for given inputs, acting as a lightweight test or runtime check.

To communicate the expectation that add(x, y) should equal expected, serving as an executable specification or test assertion.

Used during development or testing when verifying the correctness of an addition function for given inputs.

Appears in unit tests, doctests, debugging sessions, or defensive programming where the correctness of add is being validated.

assert <function_call>(<arg1>, <arg2>) == <expected>

assert <function>(<arg1>, <arg2>) == <expected>

add: function taking two numeric arguments, x: first operand (int/float), y: second operand (int/float), expected: expected result of add(x, y)

• def add
• test_
• assertEqual
• pytest
• unittest

• assert add(x
• y) == expected (direct equality)
• alternatively use assert add(x
• y) ~= expected for approximate equality
• or use a testing framework's assertEqual.

Using assignment (=) instead of equality (==) leading to SyntaxError: invalid syntax Floating-point equality issues causing false failures due to precision Floating point rounding errors causing false negatives when using == Misunderstanding short-circuit behavior: assert only raises AssertionError if False; side effects in add won't run if assertion is disabled via -O Confusing assert with pytest's assert which provides better introspection

assert add(x, y) == expected vs. pytest.assert_equal(add(x, y), expected) – latter gives better error messages assert vs. if‑raise: assert is for debugging/internal checks, if‑raise is for production error handling assert vs. logging: assert halts execution on failure, logging merely records

Coming from C: may forget that assert is a statement, not a function call, and write assert(add(x, y) == expected) which still works but is less idiomatic Coming from Java: may expect assert to be enabled by default; in Python asserts can be disabled with -O flag, leading to silent failures Coming from JavaScript: may try to use assert as a function from a library, forgetting it's a built‑in statement

• assert statement
• assertion testing
• runtime assertion
• executable specification

Assert statements are primarily intended for debugging and internal consistency checks; they can be globally disabled with Python's -O optimization flag, so they should not be used for enforcing runtime contracts in production code. Performance impact is negligible when enabled, but zero when disabled. Boundary condition: if add raises an exception, the assert will propagate that exception rather than failing with AssertionError.

Provides immediate feedback during development when assumptions about add's behavior are violated, helping catch bugs early and serving as executable documentation.

Think of assert as a safety net that shouts when your assumption about add(x, y) is wrong, stopping execution so you can fix the mistake before it propagates.

While useful for quick sanity checks, for comprehensive testing prefer a testing framework like pytest which offers richer assertions and test discovery.

Consider migrating to pytest's assert or using unittest.assertEqual for richer failure reports and test suite integration.