Tutorials : Unit Testing Java Programs :

The Round class

For the Round class we'll need a method--newScore--to enter the strokes for the hole we've just played. To get the current score we define a method called currentScore. A simple implementation of Round will now look like this:

package hansen.playground;
	import java.util.*;
	
	public class Round {
	  private String player; // name of player
	  private Course course; // name of the course
	  private int[] score; // scores for each hole
	  private int currentHole = 0; // the last played hole
	  
	  /*
	  * Set the name of the player
	  */
	  public void setPlayer(String name) {
	    player = name;
	  }
	  
	  /*
	  * Set the course
	  */
	  public void setCourse(Course c) {
	    course = c;
	    score = new int[course.getNumberOfHoles()];
	  }
	  
	  /*
	  * Set the number of strokes for the current hole
	  */
	  public void newScore(int s) {
	    score[currentHole] = s;
	    currentHole++;
	  }
	  
	  /*
	  * Get the number of strokes used so far
	  */
	  public int currentStrokes() {
	    int sum = 0;
	    for (int i = 0; i < currentHole; i++) { 
	      sum += score[i];
	    }
	    return sum;
	  }
	  
	  /*
	  * Get the current score relative 
	  *to the par of the course
	  */
	  public int currentScore() {
	    return currentStrokes() - 
			course.parUpToHole(currentHole);
	  }
	}

Testing the Round class

Now we'll make a test program for Round. In this class we have several methods to test. Let's make a test program where Tiger Woods tries to beat the Danish player Thomas Bjorn:

package hansen.playground;
	import junit.framework.*;
	
	public class TestRound extends TestCase { 
	  private Course c;
	  private Round tb,tw;
	    
	  public TestRound(String name) {
	    super(name);
	  }
	
	  protected void setUp() { 
	    c = new Course();
	    c.setName("St. Andrews");
	    int[] par = {4,4,4,4,5,4,4,3,4,4,3,4,4,5,4,4,4,4};
	    c.setPar(par); 
	    tb = new Round();
	    tb.setPlayer("Thomas Bjorn");
	    tb.setCourse(c);
	    tw = new Round();
	    tw.setPlayer("Tiger Woods");
	    tw.setCourse(c); 
	  }
	
	  public static void main(String args[]) {
	    junit.textui.TestRunner.run(TestRound.class);
	  }
	
	  public void testTiger() {
	    // Test that beginning score is zero
	    assertEquals(0, tw.currentStrokes());
	    // Player gets a "par" 
	    tw.newScore(4);
	    assertEquals(4, tw.currentStrokes());
	    assertEquals(0, tw.currentScore());
	    // Player gets a "birdie" 
	    tw.newScore(3);
	    assertEquals(7, tw.currentStrokes());
	    assertEquals(-1, tw.currentScore());
	  }
	    
	  public void testThomas() {
	    // Player gets a "bogey" 
	    tb.newScore(5);
	    assertEquals(5, tb.currentStrokes());
	    assertEquals(1, tb.currentScore());
	    // Player gets an "eagle" 
	    tb.newScore(2);
	    assertEquals(7, tb.currentStrokes());
	    assertEquals(-1, tb.currentScore());
	  }    
	}

Note that we have made two test methods in this class. It's solely our decision how many methods we find convenient to define.

Using the TestRunner batch interface on this test case will give this output:

..
	Time: 0,06
	
	OK (2 tests)

"2 tests" means that there were two methods called "testXXX" being executed. The two dots over "Time" also show that we executed 2 test methods.

More about TestRunner

When you invoke the TestRunner tool you give it the name of the class containing your test methods. By the Java-technique called "introspection" TestRunner locates all the methods starting with "test" and runs them. If you only want some of your tests to be run you should define a static method called "suite" and let it return a "TestSuite", which defines the tests to be run. If we only want the "Tiger Woods" test to be run, we define "suite" like this:

public static Test suite() { 
	  TestSuite suite= new TestSuite(); 
	  suite.addTest(new TestRound("testTiger")); 
	  return suite;
	}

To run both tests we add an extra line:

public static Test suite() { 
	  TestSuite suite= new TestSuite(); 
	  suite.addTest(new TestRound("testTiger")); 
	  suite.addTest(new TestRound("testThomas")); 
	  return suite;
	}

Running all tests can also be achieved by this somewhat simpler code:

public static Test suite() { 
	  return new TestSuite(TestRound.class);
	}

When calling TestRunner in the main method we'll now have to specify "suite" in stead of the class name:

junit.textui.TestRunner.run(suite());

It's common practice to define the "suite" method in every TestCase class, since it makes it possible to select the test cases you want to run while you are developing your code. But the "suite" is also used when you want to collect your test cases into one case.

How to Add Java Applets to Your Site

New on the Java Boutique:

New Review:

Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling API boasts simplicity, ease-of-integration, a well-rounded feature set, and it's free!

New Applet:

Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA sequences into three useful formats.

Elsewhere on internet.com:

WebDeveloper Java
Lots of Java information on webdeveloper.com

WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.

ScriptSearch Java
Hundreds of free Java code files to download.

jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.