Testing and Debugging Code

From Script to Reusable Function

A grading program becomes easier to reuse and debug when its logic is placed inside a function named computegrade. The function accepts one score and returns a letter grade as a string. Once the function works, you can call it repeatedly without rewriting the grading logic. If a result is wrong, the function gives you one focused place to investigate.

Following the Threshold Cascade

The conditions must be checked from highest to lowest. For a score of 0.85, the A condition is false because 0.85 is less than 0.9. The next condition, for B, is true because 0.85 is at least 0.8, so the function returns B. It does not continue checking later conditions after finding the first true condition.

def computegrade(score):
    if score >= 0.9:
        return "A"
    elif score >= 0.8:
        return "B"
    elif score >= 0.7:
        return "C"
    elif score >= 0.6:
        return "D"
    else:
        return "F"

Tracing a Score of 0.75

Debugging means comparing the expected path with the actual path. For 0.75, the expected result is C. If the program instead returned A or B, tracing the conditions would show that the error is in the comparison logic or in the order of the branches. Because if and elif stop at the first true condition, an incorrectly ordered cascade can prevent the correct branch from ever being reached.

Checking Boundary Values

Every threshold is inclusive. That means a score exactly equal to 0.9 receives A, exactly 0.8 receives B, exactly 0.7 receives C, and exactly 0.6 receives D. Testing only ordinary values can miss mistakes in comparison operators, so boundary values deserve their own tests.

Handling Invalid Input

A user may enter a non-numeric value such as the word perfect instead of a score. The function should handle this situation gracefully rather than allowing the program to crash. A try-except block can attempt to convert the input to a float. If that conversion fails, the except block returns the string A Bad score.

def computegrade(score):
    try:
        score = float(score)
    except:
        return "A Bad score"

    if score >= 0.9:
        return "A"
    elif score >= 0.8:
        return "B"
    elif score >= 0.7:
        return "C"
    elif score >= 0.6:
        return "D"
    else:
        return "F"

computegrade("perfect") returns "A Bad score"

Testing the Function Systematically

A function is not verified by testing only one convenient score. Systematic testing uses several kinds of input: values from every grade range, values exactly on the thresholds, values just below thresholds, and invalid non-numeric input. Comparing each actual result with its expected result helps reveal incorrect conditions, incorrect branch order, and missing error handling.

tests = [0.95, 0.90, 0.85, 0.80, 0.75, 0.70, 0.65, 0.60, 0.50, "perfect"]

for test_score in tests:
    print(test_score, computegrade(test_score))

• Checking thresholds from lowest to highest

  A broad low-threshold condition can become true before the function reaches the more specific higher-grade conditions.

  Fix: Check from the highest threshold downward and rely on the first true condition.

• Forgetting that thresholds are inclusive

  The grading criteria state that a score exactly equal to a threshold receives that grade.

  Fix: Use greater-than-or-equal comparisons for the A, B, C, and D thresholds.

• Testing only ordinary scores

  A function can appear correct for middle-of-range values while still failing at boundaries.

  Fix: Include exact thresholds and values around them in the test set.

• Allowing non-numeric input to crash the function

  The input cannot be used as a numerical score.

  Fix: Attempt conversion inside try-except and return "A Bad score" when conversion fails.

Practice and Verification

Reliable Grade Computation

1. computegrade turns a numerical score into a reusable letter-grade result.
2. Conditions must be checked from the highest threshold to the lowest because the function stops at the first true condition.
3. Thresholds are inclusive: exact values of 0.9, 0.8, 0.7, and 0.6 receive A, B, C, and D respectively.
4. A try-except block lets the function return A Bad score for non-numeric input instead of crashing.
5. Systematic tests should cover representative values, boundaries, values around boundaries, and invalid input.