Testing and Debugging

1. The three types of programming error

2. Iterative vs terminal testing

Iterative testing happens during development. Every time you finish a function or feature, you test it. If it fails you fix it immediately, while the code is fresh in your mind.

Terminal testing happens at the end on the whole assembled program against the original requirements. It is where you check that all the pieces still work together, that the user interface flows correctly, and that the program handles realistic full-scale data.

Both are required by the exam boards. Iterative testing catches bugs early when they are cheap to fix. Terminal testing catches the bugs that only appear when modules interact.

3. A proper test plan: normal, boundary, erroneous

For every input, your test plan must include all three kinds of data. Below is a test plan for a function that accepts ages between 0 and 130 inclusive.

Test  | Input | Type        | Expected output
------|-------|-------------|---------------------------
1     | 14    | Normal      | Accepted, store 14
2     | 65    | Normal      | Accepted, store 65
3     | 0     | Boundary    | Accepted (lower edge)
4     | 130   | Boundary    | Accepted (upper edge)
5     | -1    | Erroneous   | Rejected with error message
6     | 131   | Erroneous   | Rejected with error message
7     | "abc" | Erroneous   | Rejected with error message
8     | ""    | Erroneous   | Rejected with error message

# A simple validate-age function under test
def validate_age(value):
    try:
        n = int(value)
    except ValueError:
        return False
    return 0 <= n <= 130

print(validate_age("14"))    # True  (normal)
print(validate_age("0"))     # True  (boundary)
print(validate_age("131"))   # False (erroneous)
print(validate_age("abc"))   # False (erroneous)

bool ValidateAge(string value)
{
    if (!int.TryParse(value, out int n)) return false;
    return n >= 0 && n <= 130;
}

Console.WriteLine(ValidateAge("14"));    // True (normal)
Console.WriteLine(ValidateAge("131"));   // False (erroneous)

4. Trace tables for finding logic errors

A trace table records how each variable changes as the program runs. It is how you catch logic errors that exception handling cannot see.

total = 0
for i in range(1, 4):
    total = total + i
print(total)

int total = 0;
for (int i = 1; i < 4; i++)
{
    total = total + i;
}
Console.WriteLine(total);

Line              | i | total | Output
------------------|---|-------|-------
total = 0         | - |   0   |
i = 1, add        | 1 |   1   |
i = 2, add        | 2 |   3   |
i = 3, add        | 3 |   6   |
print(total)      | 3 |   6   |   6

If the expected output was 10 (1+2+3+4), the trace table immediately shows the loop ended one iteration too early - a classic off-by-one bug fixed by changing range(1,4) to range(1,5).

5. A trace table for an if/else

Trace tables are not only for loops. Use them whenever the variables change in a way that is not obvious.

x = 6
y = 3
if x > y:
    z = x - y
else:
    z = y - x
print(z)

Line          | x | y | z | Output
--------------|---|---|---|-------
x = 6         | 6 | - | - |
y = 3         | 6 | 3 | - |
x > y? Yes    | 6 | 3 | - |
z = x - y     | 6 | 3 | 3 |
print(z)      | 6 | 3 | 3 |   3

Notice that the else branch never ran. Trace tables make conditional flow explicit, which is exactly what an examiner is testing in "complete the trace table" questions.

6. Practical debugging strategies

When a bug appears, don't guess. Use a sequence:

1. Reproduce. Find the exact input that triggers it. A bug you cannot reproduce is a bug you cannot fix.
2. Isolate. Comment out lines or add print statements to narrow down which line introduces the problem.
3. Trace. Walk through the suspect lines on paper or with a debugger, recording each variable like a trace table.
4. Hypothesise. Form a single specific theory about what is wrong.
5. Fix and re-test. Make the smallest change that should fix the theory, then re-run all tests, including ones that already passed.

7. A six-mark question, fully marked

Question: A program calculates the percentage a student scored on a test out of 80. Write a test plan with three test cases (one of each type) and explain how each test would help find a different kind of bug. [6 marks]