JavaBeat

Expected Exception Test in JUnit 4

by Leave a Comment

In my previous article I have written down the sample code for Junit 4 testing using annotations. In this tutorial I would like to write about expected exception testing and Rules which is introduced from JUnit 4.7. JUnit 4 introduced the expected parameter, which makes a test succeed if and only if a certain exception is thrown. In some scenarios programmers has to test the custom exceptions which are expected if a condition failes. So, testing exception also become more important for the JUnit testing.

With JUnit 4.7, it introduced @Rules annotations for defining the expected exception object for the class level and then it will be used inside all the methods. One advantage of using this is that you can check the expected message from the exception. Another traditional approach is to use @Test(expected = NullPointerException.class) syntax on each method. Look at the below example.

[code lang=”java”]
package javabeat.net.junit;

import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

public class JUnitExceptionTest {
@Rule public ExpectedException exception = ExpectedException.none();

@Test(expected = NullPointerException.class)
public void nullPointerExceptionTest() {
String testStr = null;
testStr.toString();
}

@Test
public void expectedExceptionTest() {
exception.expect(NullPointerException.class);
exception.expectMessage("Message");
String testStr = null;
testStr.toString();
}
}
[/code]

JUnit 4 Annotation Example

by Leave a Comment

This tutorial explains the basic usage of JUnit 4 annotations. JUnit is the most popular Unit testing framework most widely used by the Java developers. After the release of Java 5.0 annotations, JUnit 4 has updated to support the annotation programming for the testing methods. Also it introduced @BeforeClass and @AfterClass methods which has to be declared as static methods. Look at the below example with annotations.

[code lang=”java”]
package javabeat.net.junit;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class JUnitTestExample {

private ArrayList<String> list;

@BeforeClass
public static void oneTimeSetUp() {
//Initialization code goes here
System.out.println("@BeforeClass");
}

@AfterClass
public static void oneTimeTearDown() {
//Release your resources here
System.out.println("@AfterClass");
}

@Before
public void setUp() {
list = new ArrayList<String>();
System.out.println("@Before – setup()");
}

@After
public void tearDown() {
list.clear();
System.out.println("@After – teardown()");
}

@Test
public void testEmptyCollection() {
assertTrue(list.isEmpty());
System.out.println("@Test Method 1");
}

@Test
public void testOneItemCollection() {
list.add("String1");
assertEquals("String1", list.get(0));
System.out.println("@Test Method 2");
}
}
[/code]

If you run the above example, the output will be:

[code]
@BeforeClass
@Before – setup()
@Test Method 2
@After – teardown()
@Before – setup()
@Test Method 1
@After – teardown()
@AfterClass
[/code]

Unit Testing with JUnit 4 Annotations

by Leave a Comment

JUnit 4.0 introduces a completely different API to the older versions. JUnit 4.0 uses Java 5.0 annotations to describe tests instead of using inheritence. It introduces more flexible initialization and cleanup, timeouts, and parameterized test cases. This post describes the new features in JUnit 4.0, and in the end, I show a basic example that tests the java.util.Stack class.

1. The tests

Unlike in JUnit 3.x you don’t have to extend TestCase to implement tests. A simple Java class can be used as a TestCase. The test methods have to be simply annotated with org.junit.Test annotation as shown below

[java]
@Test
public void emptyTest() {
stack = new Stack<String>();
assertTrue(stack.isEmpty());
}
[/java]

2. Using Assert Methods

In JUnit 4.0 test classes do not inherit from TestCase, as a result, the Assert methods are not available to the test classes. In order to use the Assert methods, you have to use either the prefixed syntax (Assert.assertEquals()) or, use a static importfor the Assert class.

[java]
import static org.junit.Assert.*;
[/java]

Now the assert methods may be used directly as done with the previous versions of JUnit.

3. Changes in Assert Methods

The new assertEquals methods use Autoboxing, and hence all the assertEquals(primitive, primitive) methods will be tested as assertEquals(Object, Object). This may lead to some interesting results. For example autoboxing will convert all numbers to the Integer class, so an Integer(10) may not be equal to Long(10). This has to be considered when writing tests for arithmetic methods. For example, the following Calc class and it’s corresponding test CalcTest will give you an error.

[java]
public class Calc {
public long add(int a, int b) {
return a+b;
}
}

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class CalcTest {
@Test
public void testAdd() {
assertEquals(5, new Calc().add(2, 3));
}
}
[/java]

You will end up with the following error.

[java]
java.lang.AssertionError: expected:<5> but was:<5>
[/java]

This is due to autoboxing. By default all the integers are cast to Integer, but we were expecting long here. Hence the error. In order to overcome this problem, it is better if you type cast the first parameter in the assertEquals to the appropriate return type for the tested method as follows

[java]assertEquals((long)5, new Calc().add(2, 3));
[/java]

There are also a couple of methods for comparing Arrays

[java]
public static void assertEquals(String message, Object[] expecteds, Object[] actuals);
public static void assertEquals(Object[] expecteds, Object[] actuals);
[/java]

4. Setup and TearDown

You need not have to create setup and teardown methods for setup and teardown. The @Before, @After and @BeforeClass, @AfterClass annotations are used for implementing setup and teardown operations. The @Before and @BeforeClass methods are run before running the tests. The @After and @AfterClass methods are run after the tests are run. The only difference being that the @Before and @After can be used for multiple methods in a class, but the @BeforeClass and @AfterClass can be used only once per class.

5. Parameterized Tests

JUnit 4.0 comes with another special runner: Parameterized, which allows you to run the same test with different data. For example, in the the following peice of code will imply that the tests will run four times, with the parameter “number” changed each time to the value in the array.

[java]
@RunWith(value = Parameterized.class)
public class StackTest {
Stack<Integer> stack;
private int number;

public StackTest(int number) {
this.number = number;
}

@Parameters
public static Collection data() {
Object[][] data = new Object[][] { { 1 }, { 2 }, { 3 }, { 4 } };
return Arrays.asList(data);
}
…
}
[/java]

The requirement for parameterized tests is to
Have the annotation @RunWith for the Test Class
Have a public static method that returns a Collection for data. Each element of the collection must be an Array of the various paramters used for the test.
You will also need a public constructor that uses the parameters

6. Test Suites

In JUnit 3.8 you had to add a suite() method to your classes, to run all tests as a suite. With JUnit 4.0 you use annotations instead. To run the CalculatorTest and SquareTest you write an empty class with @RunWith and @Suiteannotations.

[java][/java]

 

[java]
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Suite.class)
@Suite.SuiteClasses({StackTest.class})
public class AllTests {
}
[/java]

The “Suite” class takes SuiteClasses as argument which is a list of all the classes that can be run in the suite.

The following is a listing of the example StackTest used in the post.

[java]
package tests;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.util.Arrays;
import java.util.Collection;
import java.util.EmptyStackException;
import java.util.Stack;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(value = Parameterized.class)
public class StackTest {
Stack<Integer> stack;

private int number;

public StackTest(int number) {
this.number = number;
}

@Parameters
public static Collection data() {
Object[][] data = new Object[][] { { 1 }, { 2 }, { 3 }, { 4 } };
return Arrays.asList(data);
}

@Before
public void noSetup() {
stack = new Stack<Integer>();
}

@After
public void noTearDown() {
stack = null;
}

@Test
public void pushTest() {
stack.push(number);
assertEquals(stack.peek(), number);

}

@Test
public void popTest() {
}

@Test(expected = EmptyStackException.class)
public void peekTest() {
stack = new Stack<Integer>();
stack.peek();
}

@Test
public void emptyTest() {
stack = new Stack<Integer>();
assertTrue(stack.isEmpty());
}

@Test
public void searchTest() {
}
}
[/java]

If you are interested in receiving the future java articles and tips from us, please subscribe here. If you have any doubts on JUnit, please post it in the comments section. If you are working on the JUnit testing environment and looking for any example code, please post it in the comments section. We will come up with the sample code to help you. If you want to share your experience on the JUnit, please write it on the comments section.