Objectives

• To introduce exception handling in Java.
• To introduce unit testing in Java.

A Calculator Application

In this lab you will develop the simple, text-based calculator shown below. As you design your application, it is a good idea to think about appropriate test cases during the analysis phase, before you design or implement your system. Then, you can retrieve and run these test cases in order to increase confidence that your design and implementation are correct. Because there are too may test cases to specify them all, it is important that you specify tests exercising the full range of the application’s functions.

As you can see from the design shown above, you must implement four text fields and a text label on the main control panel, placed on the “North” and one message label, placed on the “South”. Do this using containment properly, as shown in this diagram.

The class structure for your application is as follows.

As you can see, this application has no Processing-based panel. The Calculator class is purely a computational class that doesn’t inherit from any JFC/Swing class, doesn’t have any instance data, and uses an empty default constructor. It just calculates. That is, it is a model and the GUI is the view. Distinguishing the model and view during the design phase will be important when you get to unit testing. The GUI controller, CalculatorController, allows the user to enter values for the two operands and the operator, and then press enter to start the calculation. Here are algorithms for the CalculatorController class.

• Declarations - Include declarations for all the text fields and labels (see the suggested names and types in the diagram above on the right), and the calculator object (calculator).
• Constructor - Implement the constructor as you have implemented constructors in previous examples:

  Title the JFrame and set the default close operation.
  Declare/initialize a controlPanel that uses a flow layout manager.
  For each of your text fields and labels:
      Initialize the field/label;
      add() the field/label to controlPanel in the appropriate order (Note, use controlPanel.add(guiObject));
      Add the action listener as you have done in the past.
  add() your controlPanel to the main frame on the “North” side;
  Initialize messageLabel and add() it to the main frame on the “South” side;
  Initialize your Calculator object (calculator).

• actionPerformed()

  Receive an ActionEvent object.
  Set operand1 = the value in operand1Field (Note, use this code to parse text in the field: Double.parseDouble(operand1Field.getText())).
  Set operator = the character in operatorField (Note, use this code to parse the first character in the field: operatorField.getText().charAt(0); this returns a char).
  Set operand2 = the value in operand2Field
  Set result = the calculated value (Note, use this code to compute the result: calculator.calculate(operand1, operator, operand2); this returns a double).
  Set the text of resultField to result value (Note, use this code: resultField.setText(Double.toString(result));)

• main() - Implement the main() method as you have implemented it on previous GUI applications.

The Calculator class itself has one method that performs basic arithmetic calculations (i.e, addition, subtraction, multiplication and division). Here are algorithms for the Calculator class.

• Declarations - Calculator has no instance data to declare.
• Constructor - Just create a default constructor method that does nothing.
• calculate()

  Receive two operands (doubles) and an operator (char) from the calling program.
  If the operator is + (addition) (Note, use this syntax: if (operator == '+')...)
        Return operand1 + operand2.
  else if the operator is - (subtraction)
        Return operand1 - operand2.
  else if the operator is * (multiplication)
        Return operand1 * operand2.
  else if the operator is / (division)
        Return operand1 / operand2.
  else
        Print an error message (using System.out.println()).
        Exit the program (using System.exit(-1)).
  Return 0.0; (Note, this will never be called but it satisfies a compiler error message.)

Exception Handling

The application you’ve developed so far does not handle anomalous user input appropriately. In this section, you add code to raise and handle exceptions properly.

The methods called in your CalculatorController#actionPerformed() method are programmed to throw the following exception types:

• NumberFormatException - when the user specifies numeric input that cannot be parsed as a number;
• StringIndexOutOfBoundsException - when the user leaves the operator text field empty ;
• Exception - when your Calculator class throws the errors you just finished programming.

You will need three catch blocks to handle these errors separately. Note that these catch blocks must be ordered as shown here, from most specific to most general (as specified in the Exception class hierarchy).

Unit Testing

JUnit tests are implemented in a separate class that constructs and exercises a Calculator object (or Calculator objects). Go through the JUnit tutorial for your IDE:

• JUnit in Eclipse

You can find a complete API reference for all of the JUnit assert commands here: http://junit.org/apidocs/org/junit/Assert.html

You can visualize the class structure of your application with a JUnit test class as follows:

If you took the wise step of specifying appropriate unit test cases during the analysis phase (see exercise 9.1), you can now implement those test cases without worrying that your tests will simply “confirm” your design and implementation rather than actually testing them. Note that you can only specify unit tests on the model class (i.e., Calculator), not on the view (CalculatorController). For example, you could test your addition calculation using the following test method:

@Test
public void calculateAdditionTest() {
	Calculator calculator = new Calculator();
	try {
		assertEquals(2.0, calculator.calculate(1, '+', 1), 1e-3);
	} catch (Exception exception) {
		fail("failed calculation unit test...");
	}
}

Checking In

Submit all the code and supporting files for the exercises in this lab.