┌─────────────────────────────────────────────────────────────────┐
│                    TEST QUALITY PYRAMID                          │
│                                                                   │
│                    ┌─────────────┐                               │
│                    │  Mutation   │  Validates test quality       │
│                    │   Testing   │  (are tests catching bugs?)   │
│                    └──────┬──────┘                               │
│                           │                                       │
│               ┌───────────┴───────────┐                          │
│               │   Property-Based      │  50x more effective      │
│               │      Testing          │  at finding bugs         │
│               └───────────┬───────────┘                          │
│                           │                                       │
│    ┌──────────────────────┴──────────────────────┐               │
│    │            Unit Tests (Examples)             │               │
│    │         Specific input → expected output     │               │
│    └──────────────────────────────────────────────┘               │
└─────────────────────────────────────────────────────────────────┘

1. Parse function/method signature
2. Identify:
   - Input types and constraints
   - Return types and invariants
   - Side effects (DB, file, network)
   - Error conditions
   - Dependencies to mock

Coverage targets:
- Happy path (normal operation)
- Edge cases (empty, nil, max values)
- Error cases (invalid input, failures)
- Boundary conditions

# Example: Property-based test for sorting
@given(lists(integers()))
def test_sort_is_idempotent(xs):
    assert sorted(sorted(xs)) == sorted(xs)

@given(lists(integers()))
def test_sort_preserves_length(xs):
    assert len(sorted(xs)) == len(xs)

@given(lists(integers()))
def test_sort_produces_ordered_output(xs):
    result = sorted(xs)
    assert all(result[i] <= result[i+1] for i in range(len(result)-1))

Mutation operators:
- Replace operators (+ → -, == → !=)
- Remove statements
- Change return values
- Modify boundary conditions

Goal: >60% mutation score

# Property-based testing
go get github.com/leanovate/gopter

# Mutation testing
go install github.com/zimmski/go-mutesting/cmd/go-mutesting@latest

# Property-based testing
uv add hypothesis

# Mutation testing
uvx mutmut run

# Property-based testing
bun add -d fast-check

# Mutation testing
bun add -d @stryker-mutator/core

func Test<Function>_<Scenario>(t *testing.T) {
    // Arrange
    input := <setup test data>
    expected := <expected result>

    // Act
    result := <Function>(input)

    // Assert
    assert.Equal(t, expected, result)
}

func TestProperty_<Invariant>(t *testing.T) {
    properties := gopter.NewProperties(nil)

    properties.Property("<invariant description>", prop.ForAll(
        func(input <Type>) bool {
            result := <Function>(input)
            return <invariant condition>
        },
        <generator>,
    ))

    properties.TestingRun(t)
}

from hypothesis import given, strategies as st

@given(st.<strategy>())
def test_<invariant>(input):
    result = function(input)
    assert <invariant condition>

# Go
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out

# Python
uv run pytest --cov=src --cov-report=html

# TypeScript
bun test --coverage

# Run mutation testing
go-mutesting ./...

# With threshold
go-mutesting --score-threshold 60 ./...

# Run mutations
uvx mutmut run

# View results
uvx mutmut results
uvx mutmut html

# Configure stryker
npx stryker init

# Run mutations
npx stryker run

Read function under test:
- Extract signature
- Identify invariants
- List edge cases
- Note dependencies

Create tests for:
1. Happy path with typical input
2. Empty/nil/zero input
3. Boundary values (max int, empty string)
4. Error conditions
5. Each error return path

Identify properties:
1. Type-level: "always returns correct type"
2. Structural: "preserves length", "maintains order"
3. Semantic: business logic invariants
4. Round-trip: encode/decode, serialize/deserialize

Run mutation testing:
- If score < 60%, add more tests
- Focus on surviving mutants
- Iterate until threshold met

1. Read function implementation
2. Identify inputs, outputs, invariants
3. Generate unit tests (happy + edge cases)
4. Generate property tests (invariants)
5. Run and verify tests pass
6. Run mutation testing
7. Add tests for surviving mutants

1. Run coverage report
2. Identify uncovered lines
3. Analyze why uncovered (edge case? error path?)
4. Generate targeted tests
5. Verify coverage improved

1. Run mutation testing
2. Review surviving mutants
3. For each survivor:
   - Add test that would kill mutant
   - Or document why mutant is equivalent
4. Re-run until score > 60%