FSc Part 2 Computer Science Chapter 5 Complete Guide Book — Code Testing and Debugging | PunjabTest.com

In this chapter, students learn the essential techniques of code testing and debugging to ensure their programs function correctly. They understand the importance of testing for creating reliable applications and explore common types of programming errors and bugs. The chapter covers unit testing using Python's unittest and pytest modules, debugging with breakpoints, watch expressions, and step-by-step debugging, exception handling for multiple exception types, and profiling and optimization to measure performance and identify bottlenecks.

Testing and Debugging Techniques: advanced testing and debugging techniques help create reliable and efficient applications. They go beyond basic error fixing to ensure program quality. These techniques identify hidden problems that may affect functionality. Testing and debugging improve performance and user satisfaction, and make future maintenance easier.

Importance of Testing and Debugging: testing and debugging are essential to ensure applications work correctly under all conditions. They help detect and remove errors before the software is released. Regular testing prevents unexpected failures during operation. Debugging locates the cause of errors and fixes them efficiently. Together, these practices increase reliability and user confidence.

Why testing is essential for reliable applications: testing checks whether an application meets its requirements. It ensures that all functions produce correct results. Testing reduces the risk of crashes or incorrect outputs. It also helps verify that changes do not break existing features. Applications that are thoroughly tested are more trustworthy and stable.

Common types of programming errors and bugs: Syntax errors occur when code does not follow language rules — e.g. missing a colon: if x > 5 (no colon) → SyntaxError: invalid syntax; the program fails to run because the Python syntax is wrong. Correct: if x > 5: print("x is greater"). Logic errors happen when the program produces incorrect results — e.g. length = 5, width = 3, area = length + width gives 8 (incorrect); correct logic area = length × width gives 15. The program runs, but the result is wrong because the formula is incorrect. Runtime errors appear while the program is running — e.g. a = 10, b = 0, result = a / b → ZeroDivisionError: division by zero; the program stops during execution because an invalid operation occurs. Other common bugs include data errors and resource leaks. Identifying these errors is key to building stable applications.

Unit testing is the process of testing individual parts or units of a program to ensure they work correctly. It helps catch errors early and makes debugging easier. Python provides modules like unittest and pytest for writing and running tests. These modules allow automated testing of functions and methods. Unit tests check whether each component produces the expected output. Writing clear and simple test cases improves code reliability.

Introduction to Python's unittest and pytest modules: the unittest module is built into Python and provides a framework for creating test cases. Pytest is an external module that simplifies writing and running tests. Both modules help verify that code behaves as expected. They can test individual functions, classes, or entire modules. Using these tools improves program stability and reduces errors in larger applications.

Writing and executing test cases: test cases define specific inputs and the expected output for a function. For example, a calculator function can be tested for addition and subtraction results. Python executes these tests and reports failures or errors. Repeated testing ensures that changes in code do not break existing functionality. Automated test execution saves time and improves accuracy in development.

# Function to test
# This function takes two input values, a and b.
# It returns the sum of both values.
def add(a, b):
    return a + b

# This function takes two input values, a and b.
# It returns the product of both values.
def multiply(a, b):
    return a * b

# Using pytest to test functions
# In pytest, every test function usually starts with the word "test_".
# Pytest automatically detects and runs these test functions.

def test_add():
    # This test checks whether the add() function gives the correct result.
    # Here, 2 and 3 are passed as input values.
    # The expected output is 5.
    assert add(2, 3) == 5  # Test passes because 2 + 3 = 5

def test_multiply():
    # This test checks whether the multiply() function gives the correct result.
    # Here, 2 and 3 are passed as input values.
    # The expected output is 6.
    assert multiply(2, 3) == 6  # Test passes because 2 * 3 = 6

Why pytest is simpler: pytest simplifies testing. It does not require test case classes or boilerplate code like unittest. The tests are written as simple functions, and assert is used to check if the output is correct. To run the tests, simply execute pytest in the command line in the directory where the file is located.

Breakpoints and watches are tools used in debugging to analyze program behavior. They allow pausing program execution and examining data at specific points. These tools help identify errors and understand how code flows. Using breakpoints and watches makes debugging faster and more precise.

Setting breakpoints in IDEs like PyCharm or VS Code: breakpoints are markers that pause program execution at a chosen line of code. IDEs like PyCharm and VS Code allow setting breakpoints with a simple click. When the program reaches a breakpoint, execution stops, and the current state can be examined. Breakpoints help focus on specific sections of code without running the entire program.

Monitoring variable values with watch expressions: watch expressions track the values of variables while the program is running. They update automatically when variable values change. This helps identify incorrect or unexpected data during execution. Watches allow observing how data changes step by step in real time.

Step-by-step debugging process: step-by-step debugging executes code one line or function at a time. It helps follow the program's logic and detect where errors occur. Developers can step into functions, step over lines, or continue execution after a breakpoint. This process makes it easier to locate and fix bugs accurately.

def calculate_area(radius):
    # Set a breakpoint here to pause and check the value of 'radius'
    area = 3.14 * radius ** 2
    return area

def main():
    # Step-by-step debugging: starting from here
    radius = 5
    print("Area of circle:", calculate_area(radius))  # Set another breakpoint here to monitor return value

    radius = 10  # Change the radius value
    print("Area of circle:", calculate_area(radius))

# Start the program
if __name__ == "__main__":
    main()

Notes: the function calculate_area(radius) calculates the area of a circle using the formula 3.14 * radius ** 2 and returns the calculated value. The main() function tests the area calculation twice by using two different radius values: 5 and 10. Breakpoints can be placed inside calculate_area() and near the print() statements to check the value of radius, observe the calculated area, and understand step-by-step debugging.

1. Setting Breakpoints in IDEs like PyCharm: in PyCharm, you can set breakpoints by clicking the line number next to the code (in the margin). When the program runs and reaches a breakpoint, it pauses. At this point, you can inspect variable values and see the current state of the program. Example: set breakpoints at radius = 5 and radius = 10 to pause the program execution at these lines.
2. Monitoring Variable Values with Watch Expressions: in your IDE, you can use watch expressions to track variables like radius during execution. When you run the debugger, watch expressions will display how the value of radius changes as the program runs. Example: you can add a watch for radius and see its value change from 5 to 10 as the program progresses.
3. Step-by-Step Debugging Process: step-by-step debugging is available in PyCharm. You can choose: Step Into — go inside a function to see how it is working (calculate_area in the example). Step Over — execute the current line and move to the next one without going inside any functions. Continue — continue the execution until the next breakpoint. Example: you can step over the line area = 3.14 * radius ** 2 to skip calculating the area, or step into calculate_area() to examine how the area is calculated.

Exception handling is used to manage errors that occur during program execution. It prevents the program from crashing and allows it to respond gracefully to unexpected situations. Proper exception handling improves program reliability and user experience. Python provides built-in tools to catch and handle exceptions efficiently. Tidbit: exception handling helps programs manage unexpected problems without stopping suddenly.

import sqlite3

try:
    # Connect to database
    connection = sqlite3.connect("school.db")
    cursor = connection.cursor()

    # Insert data into table
    cursor.execute("INSERT INTO students (ID, Name, Age) VALUES (?, ?, ?)", (1, "Ali", 20))

    # Save changes (ensures data integrity)
    connection.commit()
    print("Data inserted successfully")

except sqlite3.Error as e:
    # Handle database errors
    print("Error occurred:", e)
    connection.rollback()  # Undo changes if error occurs

finally:
    # Close connection
    if connection:
        connection.close()
        print("Connection closed")

Key points: try-except → handles errors and prevents crashes; commit() → saves correct data (ensures integrity); rollback() → cancels changes if error occurs; finally → safely closes the database.

Handling multiple exception types effectively: a single program may encounter different types of exceptions. Python allows catching multiple exceptions in one try-except block. Each exception type can be handled with a specific response. This approach prevents unexpected crashes and ensures proper error recovery. Handling multiple exceptions improves program stability and control over errors.

Profiling and optimization help improve the speed and efficiency of a program. Profiling measures how much time and resources each part of the code uses. Optimization focuses on making slow or resource-heavy parts faster. These techniques are important for building high-performance applications. Regular profiling ensures that code remains efficient as it grows. Do You Know? Profiling helps identify slow parts of a program so they can be improved for better performance.

Bottleneck example — nested loop: the following code shows a nested loop:

for i in range(10000):
    for j in range(10000):
        # Some repeated task
        pass

In this code, the outer loop runs 10,000 times. For every single iteration of the outer loop, the inner loop also runs 10,000 times. Therefore, the total number of executions becomes: 10000 × 10000 = 100,000,000. This means the inner statement may run one hundred million times, which can make the program very slow. Such a part of the code is called a performance bottleneck. Profiling tools help programmers identify these slow sections so that they can optimise the code and improve program efficiency.

Measuring performance using profiling tools: profiling tools track the execution time and memory usage of different functions in a program. Python provides modules like cProfile and timeit for this purpose. These tools generate reports showing which parts of the code are slow or resource-intensive. Measuring performance helps prioritize areas for optimization. A profiling report highlights bottlenecks — e.g. in the book's report table, process_data (10 calls, cumulative time 2.500) and read_file (1 call, 2.400) are flagged as bottlenecks, while analyze_results (10 calls, 0.100) is not.

Identifying and fixing performance bottlenecks: performance bottlenecks are sections of code that slow down the program. Profiling reports help locate these bottlenecks. Optimization techniques include improving algorithms, reducing unnecessary operations, or using efficient data structures. Fixing bottlenecks improves overall program speed and responsiveness. The performance test cycle is: Benchmark Run → Verifying results → Infrastructure (network, CPU, disks) → Bottleneck → Fixing bottleneck → Profile → Tuning → Refining tunings → Collecting configuration → Collecting component characteristics → Profiling the application (monitoring and profiling tool) → back to Benchmark Run.

import cProfile
import timeit

# Slow code example
def slow_sum(numbers):
    total = 0

    # Adding numbers one by one using a loop
    for num in numbers:
        total = total + num

    return total

# Fast code example
def fast_sum(numbers):
    # Python built-in sum() is faster and optimised
    return sum(numbers)

# Main function
def main():
    numbers = list(range(1, 1000000))

    print("Slow code result:", slow_sum(numbers))
    print("Fast code result:", fast_sum(numbers))

# Profiling the program using cProfile
print("Profiling Report:")
cProfile.run("main()")

# Comparing execution time using timeit
numbers = list(range(1, 1000000))

slow_time = timeit.timeit(lambda: slow_sum(numbers), number=10)
fast_time = timeit.timeit(lambda: fast_sum(numbers), number=10)

print("\nTime Comparison Report:")
print("Slow code time:", slow_time)
print("Fast code time:", fast_time)

Results: cProfile generates a profiling report that shows how much time each function takes during program execution. slow_sum() is slower because it adds numbers manually using a loop. fast_sum() is faster because it uses Python's built-in sum() function, which is already optimised. The function taking more execution time is called the bottleneck. timeit helps compare the execution time of slow and fast code. Output (exact time values may be different on each computer): Profiling Report: Slow code result: 499999500000, Fast code result: 499999500000, 6 function calls in 0.080 seconds — <module> 0.060, slow_sum 0.050, {built-in sum} 0.010, fast_sum 0.010, main 0.080. Time Comparison Report: Slow code time: 0.42, Fast code time: 0.09. Both functions give the same result: 499999500000. slow_sum() takes more time because it uses a manual loop. fast_sum() takes less time because it uses Python's built-in sum() function. Therefore, slow_sum() is the bottleneck in this program.

Answer key (from the book): 1–B, 2–D, 3–B, 4–C, 5–B, 6–B, 7–B, 8–B, 9–A, 10–B.