Analyse an existing program and make amendments to enhance functionality

12.3 Program Testing and Maintenance

Learning Objective

Analyse an existing program and make amendments to enhance functionality while ensuring reliability and maintainability.

Why Testing and Maintenance Matter

• Detect and correct faults before deployment.
• Ensure the program meets the specified requirements.
• Reduce long‑term costs by preventing error‑propagation.
• Facilitate future enhancements and adaptations.

Types of Testing

1. Unit Testing – test individual modules or functions in isolation.
2. Integration Testing – verify interactions between combined modules.
3. System Testing – evaluate the complete integrated system against requirements.
4. Acceptance Testing – confirm the system satisfies the end‑user’s needs.

Testing Techniques

• Black‑box (functional) testing: focus on inputs and expected outputs without regard to internal structure.
• White‑box (structural) testing: use knowledge of the code (e.g., statement coverage, branch coverage).
• Boundary‑value analysis: test at the edges of input domains.
• Equivalence partitioning: divide inputs into classes that should be treated similarly.

Typical Test‑Case Format

Analysing an Existing Program

When presented with a piece of code, follow these steps:

1. Read the specification and identify functional requirements.
2. Trace the program manually with representative data.
3. Identify any violations of coding standards or design principles.
4. Run the existing test suite (if provided) and note failures.
5. Document observed faults using the test‑case format above.

Common Fault Types

• Logical errors (incorrect algorithmic steps).
• Off‑by‑one errors in loops or array indexing.
• Incorrect use of operators (e.g., assignment “=” vs equality “==”).
• Missing or inadequate input validation.
• Resource leaks (e.g., files not closed).
• Hard‑coded values that hinder re‑use.

Making Amendments – A Structured Approach

1. Identify the required enhancement – clearly state the new functionality or performance goal.
2. Design the change – consider impact on existing modules, data structures, and interfaces.
3. Update the code – apply the modification, adhering to good coding practice (meaningful names, comments, modular design).
4. Extend the test suite – add test cases that cover the new behaviour and regression tests for unchanged parts.
5. Run all tests – ensure no existing functionality is broken.
6. Document the change – update comments, design diagrams, and the maintenance log.

Example: Refactoring a Factorial Function

Original code (Python‑style pseudocode):

def factorial(n):
result = 1
for i in range(1, n):
result = result * i
return result

Issues identified:

• Loop stops at n‑1 – off‑by‑one error.
• No input validation for negative numbers.
• Hard‑coded start value 1 makes the function less reusable for other products.

Amended version:

def factorial(n):
"""Return n! for non‑negative integers."""
if n < 0:
raise \cdot alueError("n must be non‑negative")
result = 1
for i in range(2, n + 1):
result *= i
return result

New test cases added (see table above) ensure the function now handles n = 0 correctly and raises an exception for negative inputs.

Documentation and Maintenance Log

Maintain a simple log entry for each amendment:

Date: 2025‑11‑22
Module: factorial.py
Change: Added input validation and corrected loop bounds.
Reason: Failed test case TC02 (off‑by‑one error) and requirement for negative‑input handling.
Tester: A. Smith
Result: All test cases now pass.

Checklist for a Successful Amendment

• Requirement clearly understood and recorded.
• Design impact assessed (dependencies, interfaces).
• Code follows naming conventions and includes comments.
• All relevant test cases (old and new) executed.
• Documentation updated (code comments, design diagrams, maintenance log).
• Peer review performed where possible.

Suggested Diagram

Summary

Effective testing and maintenance involve systematic analysis, rigorous test design, careful code amendment, and thorough documentation. By following the structured approach outlined above, students can reliably enhance existing programs while preserving – and often improving – overall software quality.