Verifies that a * (b + 1) equals a * b + a for randomly generated integers a and b.

Asserts that multiplication distributes over addition as a property-based test.

When writing property-based tests for arithmetic properties using the hypothesis library.

Property-based testing, hypothesis library, integer arithmetic, educational examples of algebraic properties.

@given(st.integers(), st.integers()) def test_mul_distributive(a, b): assert a * (b + 1) == a*b + a

@given(st.integers(), st.integers()) def test_mul_distributive(a, b): assert a * (b + 1) == a*b + a

a: int, b: int

• hypothesis
• given
• integers
• assert
• distributive property

• Could test associativity: a + (b + c) == (a + b) + c
• could test commutativity: a * b == b * a
• could use different numeric types like floats.

Using fixed example values instead of strategies (cause: misunderstanding property-based testing; consequence: misses edge cases); omitting the hypothesis decorator (cause: forgetting @given; consequence: test runs with fixed arguments, not randomized); miswriting the expression (cause: algebraic mistake; consequence: false failures); using non-integer strategies without adjusting expression (cause: type mismatch; consequence: test failures); asserting equality with floating point numbers without tolerance (cause: floating-point rounding; consequence: false negatives).

Associativity: a + (b + c) == (a + b) + c (groups differently); Commutativity: a * b == b * a (order of operands); Identity: a * 1 == a (multiplicative identity); Left-distributivity: a * (b + c) == a*b + a*c (distribution over addition); Right-distributivity: (a + b) * c == a*c + b*c (distribution over addition from left).

Coming from traditional unit testing: may write example-based tests instead of property-based, missing edge cases → adopt hypothesis strategies to generate diverse inputs.; Coming from languages without built-in property testing (e.g., Java JUnit): may overlook need for generators → learn hypothesis strategies for generating test data.

• property-based testing
• hypothesis
• algebraic properties

Not suitable for testing non-mathematical properties where logical invariants are hard to express; property-based testing can be slower due to many generated examples, affecting test suite runtime; boundary conditions such as integer overflow or underflow must be considered because strategies may produce extreme values.

Ensures that algebraic properties hold across a wide range of random inputs, increasing confidence in correctness and catching edge-case bugs early.

Like checking that a recipe works for any amount of ingredients, not just one specific serving.

Progress to stateful property-based testing or rule-based testing with hypothesis's rule-based state machines.