Java Programming: Testing the Edges

To produce a quality product, software engineers must fully test the written code. If this software development process step is not completed, it is likely that the user experience will not be good and thus, the product will not be used. To adequately test all aspects of code, all cases (possible situations) must be explored to see if the program acts as it was designed to function. A lack of software testing, or even ineffective testing, can lead to software updates (called patches) being necessary. This "hole" in the process can make software vulnerable to costly security breaches, both in human and economic terms. In the activity, students design test cases for a program to fully test the program.

After this activity, students should be able to:

• Apply the software/systems design process to create test cases to properly test software to see if it functions correctly.
• Relate the steps they complete in this activity to the full software/systems design process.

This activity is designed for use in a Java programming class. The teacher should have a strong knowledge of Java programming and Java programming environments. Students must have a working knowledge of Java, although it does not have to be advanced. In order to design test cases as part of a larger design process, students must be able to develop code that needs to be tested.

This activity provides you with experience in the implementation of the software/systems engineering design process. This process is cyclical. You work through a series of steps to create a product that fits predefined criteria and functions correctly.

In the first part of the activity, you work in pairs to design and write a Java function that performs a certain task, as well as design and create test cases for another student group's Java function. Then you switch products to see if your test cases function correctly. After this is attempted, we will discuss the results as a class and brainstorm what could have changed or been implemented differently.

In the second part of the activity, you design a full test suite for a problem to determine if your solution properly tests the situation.

Background

Students gain experience with the software design process in two ways. First, the focus of the activity is properly testing code that has already been designed and written. This step is critical to the successful completion of a product. Secondly, student completes a mini-design process within the larger design process to develop the test cases required to properly test software. As students progress through this activity, they should note how the steps they are performing comprise the design process.

Before the Activity

• Make copies of the Test Problem Scenarios (PDF), Test Implementation Scenarios (PDF) and Test Case Results Worksheet (PDF), one each per student.
• Download/install a Java programming environment on the student computers.

With the Students

Part I

1. Review the software design process with students and reiterate that the testing phase is a critical component of the process.
2. Explain that writing test cases is a mini-software design process, inside of the larger design process.
3. Have students each pick a partner to create Java functions and test cases. If an odd number of students, form one group of three students. Provide each student with the test problems handout, which presents two problems.
4. Assign half the student pairs as "A" groups, and the other half as "B" groups.
5. Each group writes a Java function for their one problem and a set of test cases for a different problem. For example, one group writes a Java function for Problem A and a set of test cases for the function based on Problem B. Conversely, another group writes a Java function for Problem B and a set of test cases for the function based on Problem A.
6. After students have had sufficient time to create their functions and test cases, pair each "A" group with a "B" group to test both functions, using the test cases the two groups created.
7. When the small groups have completed testing, bring the class together to discuss the results of their programming and testing.
8. As a class, create a list of test cases for each function (A and B), and discuss how many and which test cases should be included in the set.

Part 2

1. Next, provide students with the test implementation handout and the worksheet . Students should read a problem statement and discuss the requirements, as outlined in that statement.
2. Once students understand the problem and its requirements, they create a set of test cases that determine whether a Java function correctly implements the requirements of the problem. Direct students to use the worksheet to organize information for this and the next two steps. Remind them that what they are doing is completing a design process to accomplish the task of testing software.
3. Remind students to note whether each test case is a normal case, an edge case, or an error case. A complete test suite includes all of these types whenever appropriate.
4. After students have created their test cases, have them use those cases to test Java functions I, II, and III in the test implementations handout.
5. Discuss whether the functions correctly implement the requirements. Have students consider the following questions in their discussion:

• If a function does not fulfill the requirements, what test case(s) show the problem?
• How can the function be modified to fulfill the requirements?

Pre-Activity Assessment

What Do You Know? Discussion: Question students on their understanding of the software/systems (engineering) design process and how it can be applied to software development. Ask students the following (or similar) questions:

• What are the steps of the software design process? (Answer: The steps include: analysis of the problem, design of a solution, implementation of the design, testing of the design, and possible extensions of the design.)
• How can you apply the software/systems design process in the creations of test cases? (Answer: To create test cases, we must analyze what we are trying to test and design the tests; when the tests are used [implemented], we must test them to see if they do what we designed them to do; if modifications need to be made, we modify or possibly apply the tests to other programs; the creation of test cases is a complete design cycle.)

Activity Embedded Assessment

Observation/Teacher-Student Discussion: As students work, ask yourself the following questions as you observe them (Part 1) or ask the students (Part 2):

Part 1 assessment questions:

• Did students write enough test cases to cover the range of possible input to the functions?
• Did students account for edge cases and error cases, if appropriate? (In the attached problems, edge cases include, for example, weapons of weight 15 or 16 for red mages. Error cases include character classes, spells or weapons that are not on the list of valid inputs, as well as spell levels/weapon weights outside the specified range.)
• Do student test cases include both input values and expected results?

Part 2 assessment questions:

• If a function does not fulfill the requirements, what test case(s) show the problem?
• How can the function be modified to fulfill the requirements?

Post-Activity Assessment

Test Case Challenge: Have students complete the Test Case Challenge (PDF) handout, which asks them to apply what they have learned in the associated lesson and this activity to create a normal test case, an edge case and an error case for two described functions. See answers in the Test Case Challenge Solutions (PDF).