Introduction to Program Testing

Active learning aligns perfectly with program testing because students must actively engage with code to understand its flaws. Through hands-on testing activities, students shift from passive readers to critical evaluators, which builds deeper comprehension of reliability and edge cases in programming.

• JC 1
• Computing
• 4 activities
• 25 min–45 min

Learning Objectives

1. Design a comprehensive set of test cases for a given Python function, including normal, boundary, and erroneous inputs.
2. Justify the necessity of code testing for software reliability and defect prevention in a professional context.
3. Evaluate the effectiveness of different test data types in identifying potential bugs within a Python program.
4. Analyze the output of test cases to identify and explain code defects.
5. Compare the outcomes of unit tests with expected results to verify function correctness.

Collaborative Problem-Solving

⏱ 30 min·Pairs

Pairs: Test Case Brainstorm

Provide a simple Python function like one summing list elements. Pairs list 6-8 test cases for normal, boundary, and erroneous data. They code and run tests in an IDE, logging passes and failures for class share.

Prepare & details

Design a set of test cases for a simple Python function.

Facilitation Tip: For the Test Case Brainstorm activity, provide a flawed function and ask pairs to list test cases before running them, which forces deliberate thinking rather than trial-and-error testing.

Setup: Groups at tables with problem materials

Materials: Problem packet, Role cards (facilitator, recorder, timekeeper, reporter), Problem-solving protocol sheet, Solution evaluation rubric

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Collaborative Problem-Solving

⏱ 45 min·Small Groups

Small Groups: Bug Hunt Relay

Distribute buggy functions among groups. Each member tests one data type, passes logs to the next for fixes. Groups present top bugs and test-driven solutions to the class.

Prepare & details

Justify the importance of testing code before deployment.

Facilitation Tip: In the Bug Hunt Relay, assign specific roles such as 'test writer,' 'debugger,' and 'reporter' to ensure every student contributes actively during the timed challenge.

Setup: Groups at tables with problem materials

Materials: Problem packet, Role cards (facilitator, recorder, timekeeper, reporter), Problem-solving protocol sheet, Solution evaluation rubric

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Collaborative Problem-Solving

⏱ 25 min·Whole Class

Whole Class: Coverage Debate

Collect student test suites for a shared function. Project results, vote on completeness using a rubric. Discuss gaps and improvements as a class.

Prepare & details

Evaluate the effectiveness of different types of test data (e.g., boundary, normal, erroneous).

Facilitation Tip: During the Coverage Debate, use a visual coverage tool like coverage.py to show untested lines in real time, making abstract concepts concrete for students.

Setup: Groups at tables with problem materials

Materials: Problem packet, Role cards (facilitator, recorder, timekeeper, reporter), Problem-solving protocol sheet, Solution evaluation rubric

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Collaborative Problem-Solving

⏱ 35 min·Individual

Individual: Personal Test Suite

Students select their own function from prior work. Independently develop and execute a full test suite, self-assess coverage, then peer swap for validation.

Prepare & details

Design a set of test cases for a simple Python function.

Facilitation Tip: For the Personal Test Suite activity, require students to annotate each test case with a brief explanation of why it was chosen, reinforcing reflective practice.

Setup: Groups at tables with problem materials

Materials: Problem packet, Role cards (facilitator, recorder, timekeeper, reporter), Problem-solving protocol sheet, Solution evaluation rubric

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Teaching This Topic

Teach testing as a mindset, not just a task, by framing bugs as learning opportunities rather than failures. Avoid rushing through test design; instead, model slow, deliberate case selection to show how thoroughness prevents future issues. Research suggests students retain testing concepts best when they experience the pain of uncovered bugs themselves, so design activities that create that 'aha' moment.

What to Expect

Students will demonstrate understanding by designing test cases that cover normal, boundary, and erroneous inputs, and by justifying their choices during discussions. They will also articulate why testing reduces long-term bugs and improves software quality through collaborative problem-solving.

Watch Out for These Misconceptions

Common Misconception

During Test Case Brainstorm, watch for students assuming that testing a few normal inputs proves code works.

What to Teach Instead

Use the activity's discussion phase to challenge this assumption by asking pairs to swap their test cases and identify missing edge cases, then expand their suites collaboratively.

Common Misconception

During Bug Hunt Relay, watch for students believing that passing tests mean no bugs exist.

What to Teach Instead

Guide the group to analyze uncovered paths in the code during the relay's wrap-up phase, using the shared debugging experience to highlight how tests only cover what they're designed to test.

Common Misconception

During Coverage Debate, watch for students thinking that testing wastes time during development.

What to Teach Instead

Refer back to the activity's time-tracking challenge by reviewing student logs to compare the effort spent fixing bugs in tested versus untested code, emphasizing efficiency through evidence.

Assessment Ideas

Quick Check

After Test Case Brainstorm, provide students with a simple Python function (e.g., a function to calculate the area of a rectangle). Ask them to write down three distinct test cases: one normal input, one boundary input, and one erroneous input. Then, ask them to state the expected output for each.

Discussion Prompt

During Coverage Debate, pose the question: 'Imagine you are developing a login system. Why is it more critical to test invalid password attempts (erroneous input) than valid ones?' Facilitate a discussion focusing on security and user experience.

Exit Ticket

After Personal Test Suite, give students a Python function and a small set of pre-written test cases. Ask them to identify which test cases are boundary values and which are normal values, and to explain why one specific test case might fail if the function has a bug.

Extensions & Scaffolding

• Challenge early finishers to write a test suite for a more complex function, such as one that processes student grades with multiple edge cases.
• Scaffolding for struggling students: Provide a template with partially completed test cases and ask them to fill in missing normal, boundary, and erroneous inputs.
• Deeper exploration: Have students research and present on how automated testing tools (e.g., pytest) integrate with CI/CD pipelines in real-world development.

Key Vocabulary

Test Case	A specific set of inputs, execution conditions, and expected results designed to verify a particular aspect of a program's functionality.
Unit Testing	A software testing method where individual units or components of a software are tested to determine if they are fit for use.
Boundary Value Testing	A test case design technique where test data is chosen at the edges or boundaries of input partitions.
Erroneous Input	Data provided to a program that is outside the expected range or format, designed to test error handling.
Assertion	A statement in a unit test that checks if a condition is true; if false, the test fails.