Unit Testing

Testing is the process of checking the functionality of an application to ensure it runs as per
requirements. Unit testing comes into picture at the developers’ level; it is the testing of single
entity (class or method). Unit testing plays a critical role in helping a software company deliver
quality products to its customers.
Unit testing can be done in two ways: manual testing and automated testing.

What is unit testing?

A unit can be a function, a class, a package, or a subsystem. So, the term unit testing refers to the
practice of testing such small units of your code, so as to ensure that they work as expected. For
example, we can test whether an output is what we expected to see given some inputs or if a
condition is true or false.

This practice helps developers to discover failures in their logic behind their code and improve the
quality of their code. Also, unit testing can be used so as to ensure that the code will work as
expected in case of future changes.
Test coverage

In general, the development community has different opinion regarding the percentage of code
that should be tested (test coverage).Some developers believe that the code should have 100% test
coverage, while others are comprised with a test coverage of 50% or less. In any case, you should
write tests for complex or critical parts of your code.
JUnit introduction
JUnit is an open source testing framework which is used to write and run repeatable automated
tests, so that we can be ensured that our code works as expected. JUnit is widely used in industry
and can be used as stand alone Java program (from the command line) or within an IDE such as
Eclipse.

JUnit provides:
• Assertions for testing expected results.
• Test features for sharing common test data.
• Test suites for easily organizing and running tests.
• Graphical and textual test runners.

JUnit is used to test:

• an entire object
• part of an object - a method or some interacting methods
• interaction between several objects

JUnit Simple Example

Calculate.java

public class Calculate {

public int sum(int var1, int var2) {
System.out.println("Adding values: " + var1 + " + " + var2);
return var1 + var2;
}
}
In the above source code, we can notice that the class has one public method named sum(), which
gets as inputs two integers,adds them and returns the result. So, we will test this method. For this
purpose, we will create another class including methods that will test each one of the methods of
the previous class (in this case, we have only one method to be tested). This is the most common
way of usage. Of course, if a method is very complex and extended, we can have more than one
test methods for this complex method. The details of creating test cases will be presented in the
next sections. Below, there is the code of the class named CalculateTest.java, which has the role of
our test class:

CalculateTest.java
import static org.junit.Assert.*;
import org.junit.Test;
public class CalculateTest {
Calculate calculation = new Calculate();
int sum = calculation.sum(2, 5);
int testSum = 7;
@Test
public void testSum() {
System.out.println("@Test sum(): " + sum + " = " + testSum);
assertEquals(sum, testSum);
}
}
Let’s explain the above code. Firstly, we can see that there is a @Test annotation above the testSum() method. This
annotation indicates that the public void method to which it is attached can be run as a test case. Hence, the testSum()
method is the method that will test the sum() public method. We can also observe a method called assertEquals(sum,
testsum). The method assertEquals ([String message], object expected, object actual) takes as inputs two objects and
asserts that the two objects are equal. If we run the test class, by right-clicking in the test class and select Run As!Junit
Test, the program output will look like that:

Adding values: 2 + 5
@Test sum(): 7 = 7

JUnit annotations
The table below presents a summary of those annotations:

Let’s see an example of a test class with some of the annotations mentioned above.
AnnotationsTest.java
package com.javacodegeeks.junit;
import static org.junit.Assert.*;
import java.util.*;
import org.junit.*;
public class AnnotationsTest {
private ArrayList testList;
@BeforeClass
public static void onceExecutedBeforeAll() {
System.out.println("@BeforeClass: onceExecutedBeforeAll");
}
@Before
public void executedBeforeEach() {
testList = new ArrayList();
System.out.println("@Before: executedBeforeEach");
}
@AfterClass
public static void onceExecutedAfterAll() {
System.out.println("@AfterClass: onceExecutedAfterAll");
}
@After
public void executedAfterEach() {
testList.clear();
System.out.println("@After: executedAfterEach");
}
@Test
public void EmptyCollection() {
assertTrue(testList.isEmpty());
System.out.println("@Test: EmptyArrayList");
}
@Test
public void OneItemCollection() {
testList.add("oneItem");
assertEquals(1, testList.size());
System.out.println("@Test: OneItemArrayList");
}
@Ignore
public void executionIgnored() {
System.out.println("@Ignore: This execution is ignored");
}
}
If we run the above test, the console output would be the
following:
@BeforeClass: onceExecutedBeforeAll
@Before: executedBeforeEach
@Test: EmptyArrayList
@After: executedAfterEach
@Before: executedBeforeEach
@Test: OneItemArrayList
@After: executedAfterEach
@AfterClass: onceExecutedAfterAll

JUnit assertions
In this section we will present a number of assertion methods. All those methods are provided by the Assert class
which extends the class java.lang.Object and they are useful for writing tests so as to detect failures. In the table below
there is a more detailed explanation of the most commonly used assertion methods.

Let’s see an example of some of the aforementioned assertions.

AssertionsTest.java
package com.javacodegeeks.junit;
import static org.junit.Assert.*;
import org.junit.Test;
public class AssertionsTest {
@Test
public void test() {
String obj1 = "junit";
String obj2 = "junit";
String obj3 = "test";
String obj4 = "test";
String obj5 = null;
int var1 = 1;
int var2 = 2;
int[] arithmetic1 = { 1, 2, 3 };
int[] arithmetic2 = { 1, 2, 3 };
assertEquals(obj1, obj2);
assertSame(obj3, obj4);
assertNotSame(obj2, obj4);
assertNotNull(obj1);
assertNull(obj5);
assertTrue(var1 var2);
assertArrayEquals(arithmetic1, arithmetic2);
}
}
In the class above we can see how these assert methods work.
• The assertEquals() method will return normally if the two compared objects are equal, otherwise
a failure will be displayed in the JUnit window and the test will abort.
• The assertSame() and assertNotSame() methods tests if two object references point to exactly the
same object.
• The assertNull() and assertNotNull() methods test whether a variable is null or not null.
• The assertTrue() and assertFalse() methods tests if a condition or a variable is true or false.

The assertArrayEquals() will compare the two arrays and if they are equal, the method will
proceed without errors.Otherwise, a failure will be displayed in the JUnit window and the test will
abort.

Features of Junit Test Framework

JUnit test framework provides the following important features:
 Fixtures
 Test suites
 Test runners
 JUnit classes

Fixtures is a fixed state of a set of objects used as a baseline for running tests. The purpose of a
test fixture is to ensure that there is a well-known and fixed environment in which tests are run so
that results are repeatable. It includes:

setUp() method, which runs before every test invocation.

tearDown() method, which runs after every test method.

import junit.framework.*;
public class JavaTest extends TestCase {
protected int value1, value2;
// assigning the values
protected void setUp(){
value1=3;
value2=3;
}
// test method to add two values
public void testAdd(){
double result= value1 + value2;
assertTrue(result == 6);
}
}

Test Suites
A test suite bundles a few unit test cases and runs them together. In JUnit, both @RunWith and @Suite
annotation are used to run the suite test. Given below is an example that uses TestJunit1 & TestJunit2 test
classes.
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
//JUnit Suite Test
@RunWith(Suite.class)
@Suite.SuiteClasses({
TestJunit1.class ,TestJunit2.class
})
public class JunitTestSuite {
}
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit1 {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
System.out.println("Inside testPrintMessage()");
assertEquals(message, messageUtil.printMessage());
}
}
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestJunit2 {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hi!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}
Test Runners
Test runner is used for executing the test cases. Here is an example that assumes the test class TestJunit
already exists.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}
 BASIC USAGE
Let us now have a basic example to demonstrate the step-by-step process of using Junit.
1. Create a Class
Create a java class to be tested
public class MessageUtil {
private String message;
//Constructor
//@param message to be printed
public MessageUtil(String message){
this.message = message;
}
// prints the message
public String printMessage(){
System.out.println(message);
return message;
}
}

2. Create Test Case Class

1. Create a java test class, say, TestJunit.java.

2. Add a test method testPrintMessage() to your test class.

3. Add an Annotaion @Test to method testPrintMessage().

4. Implement the test condition and check the condition using assertEquals API of
Junit.
Create a java class file name TestJunit.java
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class TestJunit {
String message = "Hello World";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
assertEquals(message,messageUtil.printMessage());
}
}
3. Create Test Runner Class

1.Create a TestRunner java class.

2. Use runClasses method of JUnitCore class of JUnit to run the test case of the
above created test class.

3. Get the result of test cases run in Result Object.

4. Get failure(s) using the getFailures() method of Result object.

5. Get Success result using the wasSuccessful() method of Result object.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;
public class TestRunner {
public static void main(String[] args) {
Result result = JUnitCore.runClasses(TestJunit.class);
for (Failure failure : result.getFailures()) {
System.out.println(failure.toString());
}
System.out.println(result.wasSuccessful());
}
}