Code Coverage vs Meaningful Testing

@isTest
static void testCalculateAndFormat() {
    Calculator calc = new Calculator();
    calc.calculateAndFormat(12, 5, '+'); // runs every line... but asserts nothing at all!
}

This test genuinely executes every line inside calculateAndFormat, contributing real percentage points to the org's code coverage — and it would pass even if the method were completely broken, because it never checks the result at all. This is exactly Lesson 1's warning, made concrete: coverage counts lines executed, not correctness verified.

@isTest
static void additionReturnsCorrectlyFormattedSum() {
    Calculator calc = new Calculator();
    String result = calc.calculateAndFormat(12, 5, '+');
    System.assertEquals('12 + 5 = 17.00', result); // Lesson 5's specific-value assertion
}

@isTest
static void divisionByZeroReturnsErrorMessage() {
    Calculator calc = new Calculator();
    String result = calc.calculateAndFormat(10, 0, '/');
    System.assertEquals('Error: cannot divide by zero.', result);
}

Same lines of Calculator covered — but now every scenario actually verifies a specific, correct outcome. This is the whole module's toolkit converging: specific assertions (Lesson 5), one scenario per test method (Lesson 2), exception paths tested explicitly (Lesson 6).

• Does every test method assert a specific expected value, not just "no exception" or "not null"? (Lesson 5)
• Are both the happy path and the exception/edge-case paths covered? (Lesson 6)
• Is there at least one bulk test (200 records) for every trigger? (Lesson 7)
• Is repeated setup extracted into a factory, keeping each test focused on what it's actually verifying? (Lesson 8)

Coverage percentage tells you how much code ran during testing; this checklist is what actually tells you whether the tests are worth trusting.