Property-based testing — Hinglish notes

4.5.17 · Coding › Software Engineering

YE HAI KYA

Key vocabulary:

Property ::= ek boolean rule jo har valid input ke liye true hai.
Generator ::= woh code jo random valid inputs produce karta hai (integers(), lists(), text()).
Shrinking ::= ek failing input milne ke baad, framework use minimal example tak simplify karta hai jo phir bhi fail karta hai.

KYUN: example tests vs property tests

Worked example Ek list ko reverse karna

Example-based:

assert reverse([1,2,3]) == [3,2,1]   # one input, one output

Weak kyun hai? Tab bhi pass hoti hai agar reverse sirf length-3 lists ke liye kaam kare.

Property-based (Hypothesis use karke):

from hypothesis import given
from hypothesis.strategies import lists, integers
 
@given(lists(integers()))
def test_reverse_twice_is_identity(xs):
    assert reverse(reverse(xs)) == xs    # property for ALL xs

Yeh step kyun? reverse(reverse(xs)) == xs ek mathematical truth hai jo values se independent hai, isliye yeh har generated list ke liye hold karni chahiye — empty, single, huge, negative.

ACCHI properties kaise dhundhen

Tumhe exact output hamesha pata nahi hota, lekin tum usually ek relationship jaante ho. Common patterns:

Formula Property patterns (algebra se derived, memorize nahi kiye)

1. Round-trip (inverse functions). Agar $g$ , $f$ ko undo karta hai: $\forall x, g (f (x)) = x$ Kyun: encode/decode, serialize/deserialize, compress/decompress definition se inverses hain.

2. Idempotence. Do baar apply karna = ek baar apply karna: $f (f (x)) = f (x)$ Kyun: sort, normalize, dedupe — ek baar ho jaane ke baad, dobara karne se kuch nahi badalta.

3. Invariant / conservation. Koi quantity preserve hoti hai: $len (sort (x s)) = len (x s)$ Kyun: sorting reorder karta hai lekin kabhi elements add/remove nahi karta.

4. Oracle (ek trusted slow version ke against test karo). $f_{fast} (x) = f_{slow} (x)$ Kyun: agar ek simple correct implementation exist karta hai, toh property hai "woh agree karte hain."

5. Metamorphic (do related inputs ko relate karo). $sort (x s) = sort (shuffle (x s))$ Kyun: output input order par depend nahi karna chahiye.

SHRINKING kaise kaam karta hai (killer feature)

Shrink loop ka mental model:

Failing input $x_{0}$ mila.
Ek "simpler" candidate $x^{'}$ propose karo (ek element drop karo, ek number halve karo).
Agar $x^{'}$ phir bhi fail kare → use rakho, recurse karo. Agar woh pass kare → discard karo, doosra simplification try karo.
Ruk jao jab koi simpler candidate fail na kare. Woh minimum report karo.

Yeh sabse simple failing case ki taraf ek greedy descent hai.

Worked example: ek buggy `average`

def average(xs):
    return sum(xs) / len(xs)
 
@given(lists(integers()))
def test_average_within_bounds(xs):
    avg = average(xs)
    assert min(xs) <= avg <= max(xs)

Common mistakes (Steel-manned)

The 80/20

Recall Feynman: 12-saal ke bachche ko explain karo

Socho tumne ek toy machine banayi jo ek moje ko andar-bahar kar deti hai. Apne chune hue teen mojon se test karne ki jagah, tumhara robot dost ghar ke har random moje ko pakad leta hai — chhote moje, bade moje, phaate moje — aur har ek ko palat deta hai. Tum robot ko nahi batate ki result kaisa dikhna chahiye; tum use ek rule batate ho: "agar tum moja palto aur phir palto, toh exactly waisa hi dikhna chahiye jaise pehle tha." Robot saikdon mojon ko try karta hai. Jab koi rule todta hai, woh tumhe messy bada moja nahi deta — woh simpler mojon ke saath swap karta rehta hai jab tak sabse chhota moja nahi milta jo phir bhi rule todta ho, phir wahi dikhata hai. Ab tumhe exactly pata hai kya galat hai.

Flashcards

Property-based test kya assert karta hai, example-based test ke unlike?

Ek rule/invariant jo SABHI valid inputs ke liye true hai, na ki ek single hardcoded input→output pair.

Property-based testing mein "shrinking" define karo.

Failing input milne ke baad, use automatically simplify karna sabse chhote/simple input tak jo phir bhi fail kare, easy debugging ke liye.

RIIOM property patterns ke naam batao.

Round-trip, Idempotence, Invariant, Oracle, Metamorphic.

Round-trip property formula do.

g(f(x)) == x for all x, jahan g, f ka inverse hai (e.g. decode(encode(x))).

Idempotence property likho.

f(f(x)) == f(x) (e.g. sort, normalize, dedupe).

@given ke andar exact expected output assert kyun nahi karte?

Random inputs ke liye answer jaanne ke liye tumhe function reimplement karna padega, uske bugs copy ho jaate hain; uski jagah ek relationship assert karo.

"Generator/strategy" kya hota hai?

Woh code jo diye gaye type ke random VALID inputs produce karta hai (integers, lists, text).

1000 random cases pass hona correctness ka proof hai?

Nahi — yeh ek sampling hai jo confidence badhata hai aur bugs dhundta hai, exhaustive proof nahi.

Sort ke liye ek invariant property?

len(sort(xs)) == len(xs) aur sorted output input ka ek permutation hai.

"Oracle" pattern kya hai?

Fast implementation ko ek simple trusted (slow) reference ke against compare karo: f_fast(x) == f_slow(x).

PBT runs har input ke liye deterministic kyun hone chahiye?

Taaki failures reproduce hon; hidden randomness/global state flaky, non-reproducible failures cause karta hai.

Connections

Unit testing — PBT example tests ko complement karta hai, replace nahi karta.
Test-driven development — properties design drive kar sakti hain.
Invariants and contracts — properties runtime-checkable invariants HAIN.
Fuzzing — random input generation ka cousin (PBT = fuzzing + structured assertions + shrinking).
Hypothesis (Python) / QuickCheck (Haskell) — original PBT tools.
Pure functions — property-test karne ki sabse aasaan cheezein (deterministic, no side effects).