The first computer bug (see Grace Hopper)

Background

One thing we've learned through decades of software engineering is that developing correct software is difficult! The best way to ensure correctness is to test thoroughly while software is being developed. JUnit is a framework that automates testing by providing a standard format for tests and an easy way to execute them (see JUnit FAQ). In today's lab, you will design and implement your own JUnit tests cases.

Collaboration: You are encouraged to work with another student to complete this lab. Each of you should submit your own copy of the code. It's okay if your files are similar or identical, as long as both of your names are present at the top.

Objectives

• Create a TestCase class for use with JUnit.

• Write JUnit test methods that use assertEquals.

• Run JUnit tests for a class or set of classes.

Key Terms

test class

A class that has the purpose of testing some other class, but is not part of the final application.

test method

A method that has the purpose of testing another method, but is not part of the final application.

assertion

A statement that should always be true. Assertions make claims about the correctness of programs.

Part 1: Using JUnit for Testing

The basic JUnit pattern is very simple:

• For every class X there is a companion class named XTest that is responsible for testing the class.
• For every method m there is a companion method testM that is responsible for testing the method.

public class BasicMath {

    public static double add(double x, double y) {
        double sum;
        sum = x + y;
        return sum;
    }

    public static double subtract(double x, double y) {
        double diff;
        diff = x - y;
        return diff;
    }

}

import junit.framework.TestCase;

public class BasicMathTest extends TestCase {

    public static void testAdd() {
        double expected;
        double actual;

        expected = 15.5;
        actual = BasicMath.add(7.2, 8.3);
        assertEquals(expected, actual);
    }

    public static void testSubtract() {
        double expected;
        double actual;

        expected = 2.2;
        actual = BasicMath.subtract(3.5, 1.3);
        assertEquals(expected, actual);
    }

}

Note in the above example:

• Test classes must import junit.framework.TestCase, and they must extend TestCase.
• Test methods are usually void and take no parameters. However, they can be as complex as you like.
• Each test method establishes an expected value and runs the corresponding method to get the actual value.
• Finally, test methods use assertEquals (or other assert methods provided by JUnit) to verify correctness.

Let's see how this process works in DrJava:

1. Copy and paste the example code above into BasicMath.java and BasicMathTest.java.

2. Make sure both files are open and then press the Compile button. You should have no errors.

3. Press the Run button. (Note that since neither class has a main method, you can't "run" them.)

4. Press the Test button. You should get a green light indicating that all tests completed successfully.

5. Now go back and "break" the code by changing the BasicMath.add method: return sum + 1;

6. Compile the new code, and then press the Test button. What happens when an assertion fails?

Part 2: Writing Basic Test Methods

7. Implement the following methods in your BasicMath class:

   • public static double multiply(double x, double y)
   • public static double divide(double x, double y)

8. Now write the corresponding test methods in BasicMathTest. Use the same pattern as in testAdd and testSubtract: establish an expected result and an actual result, then compare the two with an assertion.

9. Floating point arithmetic (i.e., using float or double in Java) is not completely accurate due to limitations in computer hardware. Use the following technique to test your multiply and divide methods:

   double expected;
   double actual;
   double error;
   
   expected = 4.1;
   actual = BasicMath.divide(12.3, 3.0);
   error = Math.abs(expected - actual);
   assertTrue(error < 1e-6);
   

10. Run your new tests to validate the new methods. Then induce errors into the new methods, just as you did before with the add method, and run the tests again to see if they are really working.

It's generally not enough to test a method just once. To be sure that the method is correct, we need to test multiple times with multiple values.

11. Add the following test cases to the testAdd method. (Copy and paste the last three lines of testAdd for each case below. For readability, separate each one with a blank line.)

    • case 1: x = 0.0, y = 0.0
    • case 2: x = -5.0, y = 3.5

12. Add two additional test cases to each of the other three test methods. Design your own expected values for these methods.

13. Write an appropriate Javadoc comment for your BasicMathTest class, including @author and @version tags.

14. Write Javadoc comments for each of the test methods. It's okay to be brief if what you are testing is straightforward.

Part 3: A More Complex Example

Add the following code to the end of your BasicMath class, but don't look too carefully at the code itself. Your goal is to find the mistakes in calculateTax by writing test cases based on its documentation.

    /**
     * Calculate the tax on the given amount based on the following rules:
     *   If the taxType is 'X' or 'x' (exempt), then tax amount is zero.
     *   If the taxType is 'M' or 'm', then tax is 11% of the amount.
     *   If the taxType is 'F' or 'f', then tax is 2% of the amount.
     *   If the taxType is anything else, then tax is 5% of the amount.
     *
     * @param amount the amount of the sale
     * @param taxType type of items purchased
     * @return amount of tax
     */
    public static double calculateTax(double amount, char taxType) {
        double tax;
        switch (taxType) {
            case 'X':
            case 'x':
                tax = 0.0;
            case 'M':
            case 'n':
                tax = 0.11 * amount;
            case 'F':
            case 'f':
                tax = 0.2 * amount;
            default:
                tax = 0.5 * amount;
        }
        return tax;
    }

15. Rather than write over a dozen test cases in a single method, create the following test methods:

    • testTypeX should test cases 'X' and 'x'
    • testTypeM should test cases 'M' and 'm'
    • testTypeF should test cases 'F' and 'f'
    • testOther should test "anything else"

16. For each of the calculateTax test methods, write at least four test cases using assertEquals. Note that you can implement many of these assertions in one line of code, for example:

    assertEquals(0.0, BasicMath.calculateTax(1.99, 'X'));

17. Run your test cases. If all your test methods are correct, all four of them should fail.

18. OPTIONAL: Can you figure out how to fix calculateTax and get your test methods to pass? You may need to learn about The switch Statement in the Java tutorials.

Submit your completed BasicMathTest.java file via Canvas by the end of the day.