Testing theory & coverage

bva.py# The classic off-by-one: "valid age is 18..65 inclusive". A buggy check uses
# `< 65` instead of `<= 65`, silently rejecting the upper boundary (65).
def eligible_buggy(age):
    return 18 <= age < 65            # BUG: excludes 65

def eligible_fixed(age):
    return 18 <= age <= 65           # correct: 65 is valid

# Boundary-Value Analysis test set: for a range [lo, hi] test
# lo-1, lo, lo+1, hi-1, hi, hi+1  (the 6 points where bugs cluster).
def bva_points(lo, hi):
    return [lo - 1, lo, lo + 1, hi - 1, hi, hi + 1]

points = bva_points(18, 65)          # [17, 18, 19, 64, 65, 66]
expected = [False, True, True, True, True, False]

# A naive "happy-path" suite only tries a middle value and both pass:
print("happy-path only  :", eligible_buggy(40) == True, eligible_fixed(40) == True)

# BVA catches the bug precisely at the upper boundary (65):
buggy = [eligible_buggy(a) for a in points]
fixed = [eligible_fixed(a) for a in points]
print("boundary points  :", points)
print("buggy  results   :", buggy)
print("fixed  results   :", fixed)
print("first mismatch   :", next(p for p, b, e in zip(points, buggy, expected) if b != e))

decision_table.py# Decision-table testing: enumerate rules over conditions, derive expected action.
# Login policy: allow only if (valid_password AND account_active AND NOT locked).
from itertools import product

def decide(valid_pw, active, locked):
    return "ALLOW" if (valid_pw and active and not locked) else "DENY"

conditions = ["valid_pw", "active", "locked"]
print(f"{'valid_pw':>9} {'active':>7} {'locked':>7} | action")
allow_rows = 0
for valid_pw, active, locked in product([True, False], repeat=3):
    action = decide(valid_pw, active, locked)
    allow_rows += action == "ALLOW"
    print(f"{str(valid_pw):>9} {str(active):>7} {str(locked):>7} | {action}")
print("rules:", 2**len(conditions), "| ALLOW rules:", allow_rows)

state_transition.pyimport unittest

# State-transition testing: a turnstile FSM. States: LOCKED, UNLOCKED.
# Events: coin, push. Illegal transitions must be rejected, not silently ignored.
class Turnstile:
    def __init__(self):
        self.state = "LOCKED"
    def coin(self):
        self.state = "UNLOCKED"        # coin always unlocks
    def push(self):
        if self.state == "UNLOCKED":
            self.state = "LOCKED"      # a valid push passes through, re-locks
            return "PASS"
        return "BLOCKED"               # pushing a locked gate is blocked

class TestTurnstile(unittest.TestCase):
    def setUp(self): self.t = Turnstile()
    def test_happy_path(self):
        self.t.coin()
        self.assertEqual(self.t.push(), "PASS")
        self.assertEqual(self.t.state, "LOCKED")
    def test_push_while_locked_is_blocked(self):
        self.assertEqual(self.t.push(), "BLOCKED")   # illegal event handled
        self.assertEqual(self.t.state, "LOCKED")
    def test_two_coins_still_one_pass(self):
        self.t.coin(); self.t.coin()                 # coin is idempotent-ish
        self.assertEqual(self.t.push(), "PASS")

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

coverage_theory.pyimport unittest

# The function under test. Two conditions in one `if` (a compound decision),
# plus a branch that returns early.
def classify(x, y):
    if x > 0 and y > 0:      # decision D1 with conditions C1:(x>0) C2:(y>0)
        return "both-pos"
    if x == y:               # decision D2
        return "equal"
    return "other"

# --- Coverage models (computed by hand so you see exactly what each counts) ---
# Statements: the 4 executable lines inside classify.
# Branches:   each decision's True AND False outcome  -> 4 branch outcomes.
# Conditions: each atomic condition True AND False     -> C1,C2 each way + D2.
STATEMENTS = {"if1", "ret_both", "if2", "ret_equal_or_other"}
BRANCHES   = {"D1-T", "D1-F", "D2-T", "D2-F"}

def run(tests):
    stmt, brch = set(), set()
    for x, y in tests:
        stmt.add("if1")
        if x > 0 and y > 0:
            stmt.add("ret_both"); brch.add("D1-T")
        else:
            brch.add("D1-F")
            stmt.add("if2")
            if x == y:
                stmt.add("ret_equal_or_other"); brch.add("D2-T")
            else:
                stmt.add("ret_equal_or_other"); brch.add("D2-F")
    return stmt, brch

def pct(got, whole):
    return f"{len(got & whole)}/{len(whole)} = {100*len(got & whole)//len(whole)}%"

# Suite A: two tests. Reaches every *statement* -> 100% statement coverage...
suite_a = [(1, 1), (-2, -2)]
sa_stmt, sa_brch = run(suite_a)
print("suite A statement:", pct(sa_stmt, STATEMENTS))
print("suite A branch   :", pct(sa_brch, BRANCHES), "-> misses", sorted(BRANCHES - sa_brch))

# ...yet it never takes the False branch of D2, so a bug there hides.
# Suite B adds a non-equal negative case to cover every branch outcome.
suite_b = [(1, 1), (-2, -2), (-2, -3)]
sb_stmt, sb_brch = run(suite_b)
print("suite B branch   :", pct(sb_brch, BRANCHES))
print("100% statement != correct:", len(sa_stmt) == len(STATEMENTS), "yet branch only", pct(sa_brch, BRANCHES))