Mastering JUnit - JUnit in Action - page 31

B

public class TestDefaultController
{
private DefaultController controller;

@Before
public void instantiate() throws Exception
{
controller = new DefaultController();
}
@Test
public void testMethod()
{
throw new RuntimeException("implement me");
}
}
Start the name of the test case class with the prefix Test B . The naming convention
isn't required, but by doing so, we mark the class as a test case so that we can easily rec-
ognize test classes and possibly filter them in build scripts. Alternatively, and depend-
ing on your native language, you may prefer to postfix class names with Test .
Next, use the @Before annotated method to instantiate DefaultController C .
This is a built-in extension point that the JU nit framework calls between test methods.
At D you insert a dummy test method, so you have something to run. As soon as
you're sure the test infrastructure is working, you can begin adding real test methods.
Although this test runs, it also fails. The next step is to fix the test!
Use a best practice by throwing an exception for test code that you haven't imple-
mented yet E . This prevents the test from passing and reminds you that you must
implement this code.
Now that you have a bootstrap test, the next step is to decide what to test first.

C

D
E

JUnit's details
The @Before and @After annotated methods are executed right before/after the
execution of each one of your @Test methods and regardless of whether the test
failed or not. This helps you to extract all of your common logic, like instantiating
your domain objects and setting them up in some known state. You can have as
many of these methods as you want, but beware that if you have more than one of
the @Before/@After methods, the order of their execution is not defined.
JUnit also provides the @BeforeClass and @AfterClass annotations to anno-
tate your methods in that class. The methods that you annotate will get exe-
cuted, only once, before/after all of your @Test methods. Again, as with the
@Before and @After annotations, you can have as many of these methods as
you want, and again the order of the execution is unspecified.

You need to remember that both the @Before/@After and @BeforeClass/@After-
Class annotated methods must be public . The @BeforeClass/@AfterClass
annotated methods must be public and static .