Property-based, mutation & fuzzing

property_based.pyimport random

# Property-based testing: instead of hand-picking examples, state a *property*
# (an invariant that must hold for ALL inputs) and check it on many random ones.
# A from-scratch mini property-tester, so this runs on the stdlib alone.
def for_all(gen, prop, trials=1000, seed=0):
    rng = random.Random(seed)
    for i in range(trials):
        x = gen(rng)
        if not prop(x):
            return ("FAIL", x)         # a counterexample
    return ("OK", trials)

# System under test: an encode/decode round-trip.
def encode(s): return s.replace("%", "%25").replace(",", "%2C")
def decode(s): return s.replace("%2C", ",").replace("%25", "%")

# Property 1 (round-trip / inverse): decode(encode(s)) == s for ALL strings.
rand_str = lambda rng: "".join(rng.choice("a,%z ") for _ in range(rng.randint(0, 8)))
print("round-trip :", for_all(rand_str, lambda s: decode(encode(s)) == s, seed=1))

# Property 2 (idempotence of sorting): sorting twice == sorting once.
rand_list = lambda rng: [rng.randint(-5, 5) for _ in range(rng.randint(0, 6))]
print("sort idempot:", for_all(rand_list, lambda xs: sorted(sorted(xs)) == sorted(xs), seed=2))

# Property 3 catches a bug: a broken decode that forgets to unescape "%25".
def decode_buggy(s): return s.replace("%2C", ",")
print("buggy decode:", for_all(rand_str, lambda s: decode_buggy(encode(s)) == s, seed=1))

metamorphic.pyimport random

# Metamorphic testing: when you have NO oracle (you can't compute the exact
# expected output), test a RELATION between outputs of related inputs instead.
# Example: a search-relevance score you can't hand-compute, but you know adding
# a matching word must not DECREASE the score (a metamorphic relation).
def score(query, doc):
    q = set(query.split()); d = doc.split()
    return sum(d.count(w) for w in q)      # count of query-word hits

rng = random.Random(0)
words = ["alpha", "beta", "gamma", "delta"]
violations = 0
for _ in range(1000):
    query = " ".join(rng.sample(words, 2))
    doc = " ".join(rng.choice(words) for _ in range(rng.randint(1, 6)))
    base = score(query, doc)
    # Metamorphic transform: append a word that IS in the query.
    q_word = query.split()[0]
    followup = score(query, doc + " " + q_word)
    if followup < base:                    # relation: must not decrease
        violations += 1
print("metamorphic relation held:", violations == 0, "| violations:", violations)

mutation.pyimport copy

# Mutation testing: judge a TEST SUITE by seeding bugs (mutants) into the code
# and checking the suite catches them. A suite that passes on buggy code is weak.
# From-scratch mutation tester: swap an operator in the source, re-exec, run tests.
SOURCE = "def add(a, b):\n    return a + b\n"

def make_tests(strong):
    # strong=True asserts a value (kills the mutant); weak just checks it runs.
    def tests(ns):
        add = ns["add"]
        if strong:
            assert add(2, 3) == 5          # pins the value -> kills '+'->'-'
        else:
            add(2, 3)                      # no assertion -> mutant survives
    return tests

MUTATIONS = [("+", "-"), ("+", "*")]       # operator-swap mutants

def mutation_score(source, tests):
    killed = 0
    for old, new in MUTATIONS:
        mutant = source.replace(old, new, 1)
        ns = {}
        exec(mutant, ns)
        try:
            tests(ns)                      # suite runs against the mutant
        except AssertionError:
            killed += 1                    # caught the bug -> mutant killed
    return killed, len(MUTATIONS)

k1, n = mutation_score(SOURCE, make_tests(strong=True))
print(f"strong suite: killed {k1}/{n}  score={100*k1//n}%")
k2, _ = mutation_score(SOURCE, make_tests(strong=False))
print(f"weak   suite: killed {k2}/{n}  score={100*k2//n}%  <- passes on buggy code!")

fuzz.pyimport random

# Fuzzing: feed many generated inputs and watch for a CRASH (an unhandled
# exception), not a wrong value. Real fuzzers are coverage-guided: they keep
# inputs that reach NEW code paths. This mini loop shows the crash-finding core.
def parse_fraction(s):
    # Buggy parser: crashes on a zero denominator (unhandled ZeroDivisionError).
    num, den = s.split("/")
    return int(num) / int(den)

def fuzz(target, gen, trials=5000, seed=0):
    rng = random.Random(seed)
    seen_paths = set()
    for i in range(trials):
        x = gen(rng)
        try:
            target(x)
            seen_paths.add("ok")
        except ZeroDivisionError:
            return ("CRASH", x, i)          # found the crashing input
        except (ValueError, IndexError):
            seen_paths.add("handled")       # expected bad-input rejections
    return ("no crash", trials)

# Generator biased toward interesting inputs (small ints, includes 0 denominator).
def gen(rng):
    n = rng.randint(-3, 3); d = rng.randint(-2, 2)
    return f"{n}/{d}"

print("fuzz result:", fuzz(parse_fraction, gen, seed=7))