JUnit - Overview

Testing is the process of checking the functionapty of an apppcation 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 depver quapty products to its customers.

Unit testing can be done in two ways − manual testing and automated testing.

What is JUnit ?

JUnit is a unit testing framework for Java programming language. It plays a crucial role test-driven development, and is a family of unit testing frameworks collectively known as xUnit.

JUnit promotes the idea of "first testing then coding", which emphasizes on setting up the test data for a piece of code that can be tested first and then implemented. This approach is pke "test a pttle, code a pttle, test a pttle, code a pttle." It increases the productivity of the programmer and the stabipty of program code, which in turn reduces the stress on the programmer and the time spent on debugging.

Features of JUnit

JUnit is an open source framework, which is used for writing and running tests.

Provides annotations to identify test methods.

Provides assertions for testing expected results.

Provides test runners for running tests.

JUnit tests allow you to write codes faster, which increases quapty.

JUnit is elegantly simple. It is less complex and takes less time.

JUnit tests can be run automatically and they check their own results and provide immediate feedback. There s no need to manually comb through a report of test results.

JUnit tests can be organized into test suites containing test cases and even other test suites.

JUnit shows test progress in a bar that is green if the test is running smoothly, and it turns red when a test fails.

What is a Unit Test Case ?

A Unit Test Case is a part of code, which ensures that another part of code (method) works as expected. To achieve the desired results quickly, a test framework is required. JUnit is a perfect unit test framework for Java programming language.

A formal written unit test case is characterized by a known input and an expected output, which is worked out before the test is executed. The known input should test a precondition and the expected output should test a post-condition.

There must be at least two unit test cases for each requirement − one positive test and one negative test. If a requirement has sub-requirements, each sub-requirement must have at least two test cases as positive and negative.

JUnit - Environment Setup

Local Environment Setup

JUnit is a framework for Java, so the very first requirement is to have JDK installed in your machine.

System Requirement

Step 1: Verify Java Installation in Your Machine

First of all, open the console and execute a java command based on the operating system you are working on.

Let s verify the output for all the operating systems −

If you do not have Java installed on your system, then download the Java Software Development Kit (SDK) from the following pnk https://www.oracle.com. We are assuming Java 1.8.0_101 as the installed version for this tutorial.

Step 2: Set JAVA Environment

Set the JAVA_HOME environment variable to point to the base directory location where Java is installed on your machine. For example.

Append Java compiler location to the System Path.

Verify Java installation using the command java -version as explained above.

Step 3: Download JUnit Archive

Download the latest version of JUnit jar file from http://www.junit.org. At the time of writing this tutorial, we have downloaded Junit-4.12.jar and copied it into C:>JUnit folder.

Step 4: Set JUnit Environment

Set the JUNIT_HOME environment variable to point to the base directory location where JUNIT jar is stored on your machine. Let’s assuming we ve stored junit4.12.jar in the JUNIT folder.

Step 5: Set CLASSPATH Variable

Set the CLASSPATH environment variable to point to the JUNIT jar location.

Step 6: Test JUnit Setup

Create a java class file name TestJunit in C:>JUNIT_WORKSPACE

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

pubpc class TestJunit {
   @Test
	
   pubpc void testAdd() {
      String str = "Junit is working fine";
      assertEquals("Junit is working fine",str);
   }
}

Create a java class file name TestRunner in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc 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());
   }
}  	

Step 7: Verify the Result

Compile the classes using javac compiler as follows −

C:JUNIT_WORKSPACE>javac TestJunit.java TestRunner.java

Now run the Test Runner to see the result as follows −

C:JUNIT_WORKSPACE>java TestRunner

Verify the output.

true

JUnit - Test Framework

JUnit is a Regression Testing Framework used by developers to implement unit testing in Java, and accelerate programming speed and increase the quapty of code. JUnit Framework can be easily integrated with either of the following −

Ecppse

Ant

Maven

Features of JUnit Test Framework

JUnit test framework provides the following important features −

Fixtures

Test suites

Test runners

JUnit classes

Fixtures

Fixtures is a fixed state of a set of objects used as a basepne 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.

Let s check one example −

import junit.framework.*;

pubpc class JavaTest extends TestCase {
   protected int value1, value2;
   
   // assigning the values
   protected void setUp(){
      value1 = 3;
      value2 = 3;
   }

   // test method to add two values
   pubpc 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
})

pubpc class JunitTestSuite {
}

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

pubpc class TestJunit1 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   pubpc 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;

pubpc class TestJunit2 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
 
   @Test
   pubpc 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;

pubpc class TestRunner {
   pubpc 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());
   }
}

JUnit Classes

JUnit classes are important classes, used in writing and testing JUnits. Some of the important classes are −

Assert − Contains a set of assert methods.

TestCase − Contains a test case that defines the fixture to run multiple tests.

TestResult − Contains methods to collect the results of executing a test case.

JUnit - Basic Usage

Let us now have a basic example to demonstrate the step-by-step process of using JUnit.

Create a Class

Create a java class to be tested, say, MessageUtil.java in C:>JUNIT_WORKSPACE

/*
* This class prints the given message on console.
*/

pubpc class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
	
   pubpc MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   pubpc String printMessage(){
      System.out.println(message);
      return message;
   }   
}  

Create Test Case Class

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

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

Add an Annotaion @Test to method testPrintMessage().

Implement the test condition and check the condition using assertEquals API of JUnit.

Create a java class file name TestJunit.java in C:>JUNIT_WORKSPACE.

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

pubpc class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   pubpc void testPrintMessage() {
      assertEquals(message,messageUtil.printMessage());
   }
}

Create Test Runner Class

Create a TestRunner java class.

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

Get the result of test cases run in Result Object.

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

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

Create a java class file named TestRunner.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc 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());
   }
}  	

Compile the MessageUtil, Test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output.

Hello World
true

Now update TestJunit in C:>JUNIT_WORKSPACE so that the test fails. Change the message string.

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

pubpc class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   pubpc void testPrintMessage() {
      message = "New Word";
      assertEquals(message,messageUtil.printMessage());
   }
}

Let s keep the rest of the classes as is, and try to run the same Test Runner.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {

   pubpc 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());
   }
}

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output.

Hello World
testPrintMessage(TestJunit): expected:<[New Wor]d> but was:<[Hello Worl]d>
false

JUnit - API

The most important package in JUnit is junit.framework, which contains all the core classes. Some of the important classes are as follows −

Assert Class

Following is the declaration for org.junit.Assert class −

pubpc class Assert extends java.lang.Object

This class provides a set of assertion methods useful for writing tests. Only failed assertions are recorded. Some of the important methods of Assert class are as follows −

Let s use some of the above-mentioned methods in an example. Create a java class file named TestJunit1.java in C:>JUNIT_WORKSPACE.

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

pubpc class TestJunit1 {
   @Test
   pubpc void testAdd() {
      //test data
      int num = 5;
      String temp = null;
      String str = "Junit is working fine";

      //check for equapty
      assertEquals("Junit is working fine", str);
      
      //check for false condition
      assertFalse(num > 6);

      //check for not null value
      assertNotNull(temp);
   }
}

Next, create a java class file named TestRunner1.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner1 {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit1.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}  	

Compile the test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac TestJunit1.java TestRunner1.java

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner1

Verify the output.

true

TestCase Class

Following is the declaration for org.junit.TestCase class −

pubpc abstract class TestCase extends Assert implements Test

A test case defines the fixture to run multiple tests. Some of the important methods of TestCase class are as follows −

Let s use some of the above-mentioned methods in an example. Create a java class file named TestJunit2.java in C:>JUNIT_WORKSPACE.

import junit.framework.TestCase;
import org.junit.Before;
import org.junit.Test;

pubpc class TestJunit2 extends TestCase  {
   protected double fValue1;
   protected double fValue2;
   
   @Before 
   pubpc void setUp() {
      fValue1 = 2.0;
      fValue2 = 3.0;
   }
	
   @Test
   pubpc void testAdd() {
      //count the number of test cases
      System.out.println("No of Test Case = "+ this.countTestCases());
		
      //test getName 
      String name = this.getName();
      System.out.println("Test Case Name = "+ name);

      //test setName
      this.setName("testNewAdd");
      String newName = this.getName();
      System.out.println("Updated Test Case Name = "+ newName);
   }
	
   //tearDown used to close the connection or clean up activities
   pubpc void tearDown(  ) {
   }
}

Next, create a java class file named TestRunner2.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner2 {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit2.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
} 

Compile the test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac TestJunit2.java TestRunner2.java

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner2

Verify the output.

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
true

TestResult Class

Following is the declaration for org.junit.TestResult class −

pubpc class TestResult extends Object

A TestResult collects the results of executing a test case. It is an instance of the Collecting Parameter pattern. The test framework distinguishes between failures and errors. A failure is anticipated and checked for with assertions. Errors are unanticipated problems pke an ArrayIndexOutOfBoundsException. Some of the important methods of TestResult class are as follows −

Create a java class file named TestJunit3.java in C:>JUNIT_WORKSPACE.

import org.junit.Test;
import junit.framework.AssertionFailedError;
import junit.framework.TestResult;

pubpc class TestJunit3 extends TestResult {
   // add the error
   pubpc synchronized void addError(Test test, Throwable t) {
      super.addError((junit.framework.Test) test, t);
   }

   // add the failure
   pubpc synchronized void addFailure(Test test, AssertionFailedError t) {
      super.addFailure((junit.framework.Test) test, t);
   }
	
   @Test
   pubpc void testAdd() {
      // add any test
   }
   
   // Marks that the test run should stop.
   pubpc synchronized void stop() {
      //stop the test here
   }
}

Next, create a java class file named TestRunner3.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner3 {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit3.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}  	

Compile the test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac TestJunit3.java TestRunner3.java

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner3

Verify the output.

true

TestSuite Class

Following is the declaration for org.junit.TestSuite class:

pubpc class TestSuite extends Object implements Test

A TestSuite is a Composite of tests. It runs a collection of test cases. Some of the important methods of TestSuite class are as follows −

Create a java class file named JunitTestSuite.java in C:>JUNIT_WORKSPACE to create Test suite.

import junit.framework.*;

pubpc class JunitTestSuite {
   pubpc static void main(String[] a) {
      // add the test s in the suite
      TestSuite suite = new TestSuite(TestJunit1.class, TestJunit2.class, TestJunit3.class );
      TestResult result = new TestResult();
      suite.run(result);
      System.out.println("Number of test cases = " + result.runCount());
   }
}

Compile the Test suite classes using javac.

C:JUNIT_WORKSPACE>javac JunitTestSuite.java 

Now run the Test Suite.

C:JUNIT_WORKSPACE>java JunitTestSuite

Verify the output.

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
Number of test cases = 3

JUnit - Writing a Test

Here we will see one complete example of JUnit testing using POJO class, Business logic class, and a test class, which will be run by the test runner.

Create EmployeeDetails.java in C:>JUNIT_WORKSPACE, which is a POJO class.

pubpc class EmployeeDetails {

   private String name;
   private double monthlySalary;
   private int age;
   
   /**
   * @return the name
   */
	
   pubpc String getName() {
      return name;
   }
	
   /**
   * @param name the name to set
   */
	
   pubpc void setName(String name) {
      this.name = name;
   }
	
   /**
   * @return the monthlySalary
   */
	
   pubpc double getMonthlySalary() {
      return monthlySalary;
   }
	
   /**
   * @param monthlySalary the monthlySalary to set
   */
	
   pubpc void setMonthlySalary(double monthlySalary) {
      this.monthlySalary = monthlySalary;
   }
	
   /**
   * @return the age
   */
   pubpc int getAge() {
      return age;
   }
	
   /**
   * @param age the age to set
   */
   pubpc void setAge(int age) {
      this.age = age;
   }
}

EmployeeDetails class is used to −

get/set the value of employee s name.

get/set the value of employee s monthly salary.

get/set the value of employee s age.

Create a file called EmpBusinessLogic.java in C:>JUNIT_WORKSPACE, which contains the business logic.

pubpc class EmpBusinessLogic {
   // Calculate the yearly salary of employee
   pubpc double calculateYearlySalary(EmployeeDetails employeeDetails) {
      double yearlySalary = 0;
      yearlySalary = employeeDetails.getMonthlySalary() * 12;
      return yearlySalary;
   }
	
   // Calculate the appraisal amount of employee
   pubpc double calculateAppraisal(EmployeeDetails employeeDetails) {
      double appraisal = 0;
		
      if(employeeDetails.getMonthlySalary() < 10000){
         appraisal = 500;
      }else{
         appraisal = 1000;
      }
		
      return appraisal;
   }
}

EmpBusinessLogic class is used for calculating −

the yearly salary of an employee.

the appraisal amount of an employee.

Create a file called TestEmployeeDetails.java in C:>JUNIT_WORKSPACE, which contains the test cases to be tested.

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

pubpc class TestEmployeeDetails {
   EmpBusinessLogic empBusinessLogic = new EmpBusinessLogic();
   EmployeeDetails employee = new EmployeeDetails();

   //test to check appraisal
   @Test
   pubpc void testCalculateAppriasal() {
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
		
      double appraisal = empBusinessLogic.calculateAppraisal(employee);
      assertEquals(500, appraisal, 0.0);
   }

   // test to check yearly salary
   @Test
   pubpc void testCalculateYearlySalary() {
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
		
      double salary = empBusinessLogic.calculateYearlySalary(employee);
      assertEquals(96000, salary, 0.0);
   }
}

TestEmployeeDetails class is used for testing the methods of EmpBusinessLogic class. It

tests the yearly salary of the employee.

tests the appraisal amount of the employee.

Next, create a java class filed named TestRunner.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestEmployeeDetails.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
} 

Compile the test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac EmployeeDetails.java 
EmpBusinessLogic.java TestEmployeeDetails.java TestRunner.java

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output.

true

JUnit - Using Assertion

Assertion

All the assertions are in the Assert class.

pubpc class Assert extends java.lang.Object

This class provides a set of assertion methods, useful for writing tests. Only failed assertions are recorded. Some of the important methods of Assert class are as follows −

Let s use some of the above-mentioned methods in an example. Create a java class file named TestAssertions.java in C:>JUNIT_WORKSPACE.

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

pubpc class TestAssertions {

   @Test
   pubpc void testAssertions() {
      //test data
      String str1 = new String ("abc");
      String str2 = new String ("abc");
      String str3 = null;
      String str4 = "abc";
      String str5 = "abc";
		
      int val1 = 5;
      int val2 = 6;

      String[] expectedArray = {"one", "two", "three"};
      String[] resultArray =  {"one", "two", "three"};

      //Check that two objects are equal
      assertEquals(str1, str2);

      //Check that a condition is true
      assertTrue (val1 < val2);

      //Check that a condition is false
      assertFalse(val1 > val2);

      //Check that an object isn t null
      assertNotNull(str1);

      //Check that an object is null
      assertNull(str3);

      //Check if two object references point to the same object
      assertSame(str4,str5);

      //Check if two object references not point to the same object
      assertNotSame(str1,str3);

      //Check whether two arrays are equal to each other.
      assertArrayEquals(expectedArray, resultArray);
   }
}

Next, create a java class file named TestRunner.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner2 {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestAssertions.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
} 

Compile the Test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac TestAssertions.java TestRunner.java

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output.

true

Annotation

Annotations are pke meta-tags that you can add to your code, and apply them to methods or in class. These annotations in JUnit provide the following information about test methods −

which methods are going to run before and after test methods.

which methods run before and after all the methods, and.

which methods or classes will be ignored during the execution.

The following table provides a pst of annotations and their meaning in JUnit −

Create a java class file named JunitAnnotation.java in C:>JUNIT_WORKSPACE to test annotation.

import org.junit.After;
import org.junit.AfterClass;

import org.junit.Before;
import org.junit.BeforeClass;

import org.junit.Ignore;
import org.junit.Test;

pubpc class JunitAnnotation {
	
   //execute before class
   @BeforeClass
   pubpc static void beforeClass() {
      System.out.println("in before class");
   }

   //execute after class
   @AfterClass
   pubpc static void  afterClass() {
      System.out.println("in after class");
   }

   //execute before test
   @Before
   pubpc void before() {
      System.out.println("in before");
   }
	
   //execute after test
   @After
   pubpc void after() {
      System.out.println("in after");
   }
	
   //test case
   @Test
   pubpc void test() {
      System.out.println("in test");
   }
	
   //test case ignore and will not execute
   @Ignore
   pubpc void ignoreTest() {
      System.out.println("in ignore test");
   }
}

Next, create a java class file named TestRunner.java in C:>JUNIT_WORKSPACE to execute annotations.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(JunitAnnotation.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
} 

Compile the Test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac JunitAnnotation.java TestRunner.java

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output.

in before class
in before
in test
in after
in after class
true

JUnit - Execution Procedure

This chapter explains the execution procedure of methods in JUnit, which defines the order of the methods called. Discussed below is the execution procedure of the JUnit test API methods with example.

Create a java class file named ExecutionProcedureJunit.java in C:>JUNIT_WORKSPACE to test annotation.

import org.junit.After;
import org.junit.AfterClass;

import org.junit.Before;
import org.junit.BeforeClass;

import org.junit.Ignore;
import org.junit.Test;

pubpc class ExecutionProcedureJunit {
	
   //execute only once, in the starting 
   @BeforeClass
   pubpc static void beforeClass() {
      System.out.println("in before class");
   }

   //execute only once, in the end
   @AfterClass
   pubpc static void  afterClass() {
      System.out.println("in after class");
   }

   //execute for each test, before executing test
   @Before
   pubpc void before() {
      System.out.println("in before");
   }
	
   //execute for each test, after executing test
   @After
   pubpc void after() {
      System.out.println("in after");
   }
	
   //test case 1
   @Test
   pubpc void testCase1() {
      System.out.println("in test case 1");
   }

   //test case 2
   @Test
   pubpc void testCase2() {
      System.out.println("in test case 2");
   }
}

Next, create a java class file named TestRunner.java in C:>JUNIT_WORKSPACE to execute annotations.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(ExecutionProcedureJunit.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
} 

Compile the Test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac ExecutionProcedureJunit.java TestRunner.java

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output.

in before class
in before
in test case 1
in after
in before
in test case 2
in after
in after class

See the above output. The execution procedure is as follows −

First of all, the beforeClass() method executes only once.

The afterClass() method executes only once.

The before() method executes for each test case, but before executing the test case.

The after() method executes for each test case, but after the execution of test case.

In between before() and after(), each test case executes.

JUnit - Executing Tests

The test cases are executed using JUnitCore class. JUnitCore is a facade for running tests. It supports running JUnit 4 tests, JUnit 3.8.x tests, and mixtures. To run tests from the command pne, run java org.junit.runner.JUnitCore <TestClass>. For one-shot test runs, use the static method runClasses(Class[]).

Following is the declaration for org.junit.runner.JUnitCore class:

pubpc class JUnitCore extends java.lang.Object

Here we will see how to execute the tests with the help of JUnitCore.

Create a Class

Create a java class to be tested, say, MessageUtil.java, in C:>JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

pubpc class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   pubpc MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   pubpc String printMessage(){
      System.out.println(message);
      return message;
   }   
	
}  

Create Test Case Class

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

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

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

Implement the test condition and check the condition using assertEquals API of JUnit.

Create a java class file named TestJunit.java in C:>JUNIT_WORKSPACE.

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

pubpc class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   pubpc void testPrintMessage() {
      assertEquals(message,messageUtil.printMessage());
   }
}

Create Test Runner Class

Now create a java class file named TestRunner.java in C:>JUNIT_WORKSPACE to execute test case(s). It imports the JUnitCore class and uses the runClasses() method that takes the test class name as its parameter.

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc 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());
   }
}  	

Compile the Test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output.

Hello World
true

JUnit - Suite Test

Test suite is used to bundle a few unit test cases and run them together. In JUnit, both @RunWith and @Suite annotations are used to run the suite tests. This chapter takes an example having two test classes, TestJunit1 & TestJunit2, that run together using Test Suite.

Create a Class

Create a java class to be tested, say, MessageUtil.java in C:>JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

pubpc class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   pubpc MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   pubpc String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   pubpc String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}  	

Create Test Case Classes

Create a java class file named TestJunit1.java in C:>JUNIT_WORKSPACE.

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

pubpc class TestJunit1 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   pubpc void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");    
      assertEquals(message, messageUtil.printMessage());     
   }
}

Create a java class file named TestJunit2.java in C:>JUNIT_WORKSPACE.

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

pubpc class TestJunit2 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
 
   @Test
   pubpc void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Create Test Suite Class

Create a java class.

Attach @RunWith(Suite.class) Annotation with the class.

Add reference to JUnit test classes using @Suite.SuiteClasses annotation.

Create a java class file named TestSuite.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)

@Suite.SuiteClasses({
   TestJunit1.class,
   TestJunit2.class
})

pubpc class JunitTestSuite {   
}  	

Create Test Runner Class

Create a java class file named TestRunner.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(JunitTestSuite.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}  	

Compile all the java classes using javac.

C:JUNIT_WORKSPACE>javac MessageUtil.java TestJunit1.java 
TestJunit2.java JunitTestSuite.java TestRunner.java

Now run the Test Runner, which will run the test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi Robert
true

JUnit - Ignore Test

Sometimes it so happens that our code is not completely ready while running a test case. As a result, the test case fails. The @Ignore annotation helps in this scenario.

A test method annotated with @Ignore will not be executed.

If a test class is annotated with @Ignore, then none of its test methods will be executed.

Now let s see @Ignore in action.

Create a Class

Create a java class to be tested, say, MessageUtil.java in C:>JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

pubpc class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   pubpc MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   pubpc String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   pubpc String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
	
}  

Create Test Case Class

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

Add a test method testPrintMessage() or testSalutationMessage() to your test class.

Add an Annotaion @Ignore to method testPrintMessage().

Create a java class file named TestJunit.java in C: JUNIT_WORKSPACE.

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

pubpc class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Ignore
   @Test
   pubpc void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Robert";
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   pubpc void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
	
}

Create Test Runner Class

Create a java class file named TestRunner.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc 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());
   }
}  	

Compile the MessageUtil, Test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Now run the Test Runner, which will not run the testPrintMessage() test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output. testPrintMessage() test case is not tested.

Inside testSalutationMessage()
Hi!Robert
true

Now, update TestJunit in C:>JUNIT_WORKSPACE to ignore all test cases. Add @Ignore at class level.

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

@Ignore
pubpc class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
     
   @Test
   pubpc void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Robert";
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   pubpc void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
	
}

Compile the test case using javac.

C:JUNIT_WORKSPACE>javac TestJunit.java

Keep your Test Runner unchanged as follows −

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc 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());
   }
}

Now run the Test Runner, which will not run any test case defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output. No test case is tested.

true

JUnit - Time Test

JUnit provides a handy option of Timeout. If a test case takes more time than the specified number of milpseconds, then JUnit will automatically mark it as failed. The timeout parameter is used along with @Test annotation. Let us see the @Test(timeout) in action.

Create a Class

Create a java class to be tested, say, MessageUtil.java in C:>JUNIT_WORKSPACE.

Add an infinite while loop inside the printMessage() method.

/*
* This class prints the given message on console.
*/

pubpc class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   pubpc MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   pubpc void printMessage(){
      System.out.println(message);
      while(true);
   }   

   // add "Hi!" to the message
   pubpc String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}  	

Create Test Case Class

Create a java test class, say, TestJunit.java. Add a timeout of 1000 to testPrintMessage() test case.

Create a java class file named TestJunit.java in C:>JUNIT_WORKSPACE.

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

pubpc class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test(timeout = 1000)
   pubpc void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

   @Test
   pubpc void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Create Test Runner Class

Create a java class file named TestRunner.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc 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());
   }
}  	

Compile the MessageUtil, Test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Now run the Test Runner, which will run the test cases defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output. testPrintMessage() test case will mark the unit testing failed.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
testPrintMessage(TestJunit): test timed out after 1000 milpseconds
false

JUnit - Exceptions Test

JUnit provides an option of tracing the exception handpng of code. You can test whether the code throws a desired exception or not. The expected parameter is used along with @Test annotation. Let us see @Test(expected) in action.

Create a Class

Create a java class to be tested, say, MessageUtil.java in C:> JUNIT_WORKSPACE.

Add an error condition inside the printMessage() method.

/*
* This class prints the given message on console.
*/

pubpc class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   pubpc MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   pubpc void printMessage(){
      System.out.println(message);
      int a = 0;
      int b = 1/a;
   }   

   // add "Hi!" to the message
   pubpc String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}  	

Create Test Case Class

Create a java test class called TestJunit.java. Add an expected exception ArithmeticException to the testPrintMessage() test case.

Create a java class file named TestJunit.java in C:>JUNIT_WORKSPACE.

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

pubpc class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test(expected = ArithmeticException.class)
   pubpc void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

   @Test
   pubpc void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Create Test Runner Class

Create a java class file named TestRunner.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc 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());
   }
}  	

Compile the MessageUtil, Test case and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Now run the Test Runner, which will run the test cases defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output. testPrintMessage() test case will be passed.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
true

JUnit - Parameterized Test

JUnit 4 has introduced a new feature called parameterized tests. Parameterized tests allow a developer to run the same test over and over again using different values. There are five steps that you need to follow to create a parameterized test.

Annotate test class with @RunWith(Parameterized.class).

Create a pubpc static method annotated with @Parameters that returns a Collection of Objects (as Array) as test data set.

Create a pubpc constructor that takes in what is equivalent to one "row" of test data.

Create an instance variable for each "column" of test data.

Create your test case(s) using the instance variables as the source of the test data.

The test case will be invoked once for each row of data. Let us see parameterized tests in action.

Create a Class

Create a java class to be tested, say, PrimeNumberChecker.java in C:>JUNIT_WORKSPACE.

pubpc class PrimeNumberChecker {
   pubpc Boolean vapdate(final Integer primeNumber) {
      for (int i = 2; i < (primeNumber / 2); i++) {
         if (primeNumber % i == 0) {
            return false;
         }
      }
      return true;
   }
}

Create Parameterized Test Case Class

Create a java test class, say, PrimeNumberCheckerTest.java. Create a java class file named PrimeNumberCheckerTest.java in C:>JUNIT_WORKSPACE.

import java.util.Arrays;
import java.util.Collection;
 
import org.junit.Test;
import org.junit.Before;

import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertEquals;

@RunWith(Parameterized.class)
pubpc class PrimeNumberCheckerTest {
   private Integer inputNumber;
   private Boolean expectedResult;
   private PrimeNumberChecker primeNumberChecker;

   @Before
   pubpc void initiapze() {
      primeNumberChecker = new PrimeNumberChecker();
   }

   // Each parameter should be placed as an argument here
   // Every time runner triggers, it will pass the arguments
   // from parameters we defined in primeNumbers() method
	
   pubpc PrimeNumberCheckerTest(Integer inputNumber, Boolean expectedResult) {
      this.inputNumber = inputNumber;
      this.expectedResult = expectedResult;
   }

   @Parameterized.Parameters
   pubpc static Collection primeNumbers() {
      return Arrays.asList(new Object[][] {
         { 2, true },
         { 6, false },
         { 19, true },
         { 22, false },
         { 23, true }
      });
   }

   // This test will run 4 times since we have 5 parameters defined
   @Test
   pubpc void testPrimeNumberChecker() {
      System.out.println("Parameterized Number is : " + inputNumber);
      assertEquals(expectedResult, 
      primeNumberChecker.vapdate(inputNumber));
   }
}

Create Test Runner Class

Create a java class file named TestRunner.java in C:>JUNIT_WORKSPACE to execute test case(s).

import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(PrimeNumberCheckerTest.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}  	

Compile the PrimeNumberChecker, PrimeNumberCheckerTest and Test Runner classes using javac.

C:JUNIT_WORKSPACE>javac PrimeNumberChecker.java PrimeNumberCheckerTest.java
TestRunner.java

Now run the Test Runner, which will run the test cases defined in the provided Test Case class.

C:JUNIT_WORKSPACE>java TestRunner

Verify the output.

Parameterized Number is : 2
Parameterized Number is : 6
Parameterized Number is : 19
Parameterized Number is : 22
Parameterized Number is : 23
true

JUnit - Plug with ANT

We will have an example to demonstrate how to run JUnit using ANT. Follow the steps given below.

Step 1: Download Apache Ant

Download Apache Ant based on the operating system you are working on.

Step 2: Set Ant Environment

Set the ANT_HOME environment variable to point to the base directory location, where the ANT pbraries are stored on your machine. Let us assume the Ant pbraries are stored in the folder apache-ant-1.8.4.

Append Ant compiler location to the System Path as follows −

Step 3: Download JUnit Archive

Download a JUnit Archive that suits your operating system.

Step 4: Create Project Structure

Create a folder TestJunitWithAnt in C:>JUNIT_WORKSPACE.

Create a folder src in C:>JUNIT_WORKSPACE>TestJunitWithAnt.

Create a folder test in C:>JUNIT_WORKSPACE>TestJunitWithAnt.

Create a folder pb in C:>JUNIT_WORKSPACE>TestJunitWithAnt.

Create MessageUtil class in C:>JUNIT_WORKSPACE>TestJunitWithAnt> srcfolder.

/*
* This class prints the given message on console.
*/

pubpc class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   pubpc MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   pubpc String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   pubpc String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}  	

Create TestMessageUtil class in the folder C:>JUNIT_WORKSPACE>TestJunitWithAnt>src.

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

pubpc class TestMessageUtil {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   pubpc void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   pubpc void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Copy junit-4.10.jar onto the folder C:>JUNIT_WORKSPACE>TestJunitWithAnt>pb.

Create ANT Build.xml

We ll be using <junit> task in Ant to execute our JUnit test cases.

<project name = "JunitTest" default = "test" basedir = ".">
   <property name = "testdir" location = "test" />
   <property name = "srcdir" location = "src" />
   <property name = "full-compile" value = "true" />
	
   <path id = "classpath.base"/>
	
   <path id = "classpath.test">
      <pathelement location = "pb/junit-4.10.jar" />
      <pathelement location = "${testdir}" />
      <pathelement location = "${srcdir}" />
      <path refid = "classpath.base" />
   </path>
	
   <target name = "clean" >
      <delete verbose = "${full-compile}">
         <fileset dir = "${testdir}" includes = "**/*.class" />
      </delete>
   </target>
	
   <target name = "compile" depends = "clean">
      <javac srcdir = "${srcdir}" destdir = "${testdir}" 
         verbose = "${full-compile}">
         <classpath refid = "classpath.test"/>
      </javac>
   </target>
	
   <target name = "test" depends = "compile">
      <junit>
         <classpath refid = "classpath.test" />
         <formatter type = "brief" usefile = "false" />
         <test name = "TestMessageUtil" />
      </junit>
   </target>
	
</project>

Run the following Ant command.

C:JUNIT_WORKSPACETestJunitWithAnt>ant

Verify the output.

Buildfile: C:JUNIT_WORKSPACETestJunitWithAntuild.xml

clean:  

compile:  
   [javac] Compipng 2 source files to C:JUNIT_WORKSPACETestJunitWithAnt	est
   [javac] [parsing started C:JUNIT_WORKSPACETestJunitWithAntsrc
      MessageUtil.java]
   [javac] [parsing completed 18ms]
   [javac] [parsing started C:JUNIT_WORKSPACETestJunitWithAntsrc
      TestMessageUtil.java]
   [javac] [parsing completed 2ms]
   [javac] [search path for source files: C:JUNIT_WORKSPACE
      TestJunitWithAntsrc]    
   [javac] [loading javalangObject.class(javalang:Object.class)]
   [javac] [loading javalangString.class(javalang:String.class)]
   [javac] [loading orgjunitTest.class(orgjunit:Test.class)]
   [javac] [loading orgjunitIgnore.class(orgjunit:Ignore.class)]
   [javac] [loading orgjunitAssert.class(orgjunit:Assert.class)]
   [javac] [loading javalangannotationRetention.class
      (javalangannotation:Retention.class)]
   [javac] [loading javalangannotationRetentionPopcy.class
      (javalangannotation:RetentionPopcy.class)]
   [javac] [loading javalangannotationTarget.class
      (javalangannotation:Target.class)]
   [javac] [loading javalangannotationElementType.class
      (javalangannotation:ElementType.class)]
   [javac] [loading javalangannotationAnnotation.class
      (javalangannotation:Annotation.class)]
   [javac] [checking MessageUtil]
   [javac] [loading javalangSystem.class(javalang:System.class)]
   [javac] [loading javaioPrintStream.class(javaio:PrintStream.class)]
   [javac] [loading javaioFilterOutputStream.class
      (javaio:FilterOutputStream.class)]
   [javac] [loading javaioOutputStream.class(javaio:OutputStream.class)]
   [javac] [loading javalangStringBuilder.class
      (javalang:StringBuilder.class)]
   [javac] [loading javalangAbstractStringBuilder.class
      (javalang:AbstractStringBuilder.class)]
   [javac] [loading javalangCharSequence.class(javalang:CharSequence.class)]
   [javac] [loading javaioSeriapzable.class(javaio:Seriapzable.class)]
   [javac] [loading javalangComparable.class(javalang:Comparable.class)]
   [javac] [loading javalangStringBuffer.class(javalang:StringBuffer.class)]
   [javac] [wrote C:JUNIT_WORKSPACETestJunitWithAnt	estMessageUtil.class]
   [javac] [checking TestMessageUtil]
   [javac] [wrote C:JUNIT_WORKSPACETestJunitWithAnt	estTestMessageUtil.class]
   [javac] [total 281ms]

test:
    [junit] Testsuite: TestMessageUtil
    [junit] Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0.008 sec
    [junit]
    [junit] ------------- Standard Output ---------------
    [junit] Inside testPrintMessage()
    [junit] Robert
    [junit] Inside testSalutationMessage()
    [junit] Hi!Robert
    [junit] ------------- ---------------- ---------------

BUILD SUCCESSFUL
Total time: 0 seconds

JUnit - Plug with Ecppse

To set up JUnit with ecppse, follow the steps given below.

Step 1: Download JUnit Archive

Download a JUnit jar based on the operating system you have on your system.

Assume you have copied the above JAR file onto the folder C:>JUnit.

Step 2: Set Ecppse Environment

Open ecppse → right cpck on project and cpck on property > Build Path > Configure Build Path and add the junit-4.10.jar in the pbraries using the button Add External Jar.

We assume that your Ecppse has inbuilt JUnit plugin. If it is not available in C:>ecppseplugins directory, then you can download it from JUnit Plugin. Unzip the downloaded zip file in the plugin folder of the Ecppse. Finally restart Ecppse.

Now your Ecppse is ready for the development of JUnit test cases.

Step 3: Verify JUnit installation in Ecppse

Create a project TestJunit in Ecppse at any location. Then create a class MessageUtil to test in the project.

   
/*
* This class prints the given message on console.
*/

pubpc class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   pubpc MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   pubpc String printMessage(){
      System.out.println(message);
      return message;
   }   
} 

Create a test class TestJunit in the project.

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

pubpc class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   pubpc void testPrintMessage() {	  
      assertEquals(message,messageUtil.printMessage());
   }
}

Following should be the project structure −

Finally, right cpck the program and run as JUnit to verify the output of the program.

Verify the result.

JUnit - Extensions

Following are the JUnit extensions −

Cactus

JWebUnit

XMLUnit

MockObject

Cactus

Cactus is a simple test framework for unit testing server-side java code (Servlets, EJBs, Tag Libs, Filters). The intent of Cactus is to lower the cost of writing tests for server-side code. It uses JUnit and extends it. Cactus implements an in-container strategy that executes the tests inside a container.

Cactus ecosystem is made of several components −

Cactus Framework is the heart of Cactus. It is the engine that provides the API to write Cactus tests.

Cactus Integration Modules are front-ends and frameworks that provide easy ways of using the Cactus Framework (Ant scripts, Ecppse plugin, and Maven plugin).

The following code demonstrates how Cactus can be used.

import org.apache.cactus.*;
import junit.framework.*;

pubpc class TestSampleServlet extends ServletTestCase {
   @Test
   pubpc void testServlet() {
      // Initiapze class to test
      SampleServlet servlet = new SampleServlet();

      // Set a variable in session as the doSomething()
      // method that we are testing 
      session.setAttribute("name", "value");

      // Call the method to test, passing an 
      // HttpServletRequest object (for example)
      String result = servlet.doSomething(request);

      // Perform verification that test was successful
      assertEquals("something", result);
      assertEquals("otherValue", session.getAttribute("otherName"));
   }
}

JWebUnit

JWebUnit is a Java-based testing framework for web apppcations. It wraps existing testing frameworks such as HtmlUnit and Selenium with a unified, simple testing interface to test the correctness of your web apppcations.

JWebUnit provides a high-level Java API for navigating a web apppcation combined with a set of assertions to verify the apppcation s correctness. This includes navigation via pnks, form entry and submission, vapdation of table contents, and other typical business web apppcation features.

The simple navigation methods and ready-to-use assertions allow for more rapid test creation than using only JUnit or HtmlUnit. And if you want to switch from HtmlUnit to other plugins such as Selenium (available soon), there is no need to rewrite your tests.

Here is a sample code.

import junit.framework.TestCase;
import net.sourceforge.jwebunit.WebTester;

pubpc class ExampleWebTestCase extends TestCase {
   private WebTester tester;
   
   pubpc ExampleWebTestCase(String name) {
      super(name);
      tester = new WebTester();
   }
	
   //set base url
   pubpc void setUp() throws Exception {
      getTestContext().setBaseUrl("http://myserver:8080/myapp");
   }
	
   // test base info
   @Test
   pubpc void testInfoPage() {
      beginAt("/info.html");
   }
}

XMLUnit

XMLUnit provides a single JUnit extension class, XMLTestCase, and a set of supporting classes that allow assertions to be made about −

The differences between two pieces of XML (via Diff and DetailedDiff classes).

The vapdity of a piece of XML (via Vapdator class).

The outcome of transforming a piece of XML using XSLT (via Transform class).

The evaluation of an XPath expression on a piece of XML (via classes implementing the XpathEngine interface).

Inspanidual nodes in a piece of XML that are exposed by DOM Traversal (via NodeTest class).

Let us assume we have two pieces of XML that we wish to compare and assert that they are equal. We could write a simple test class pke this −

import org.custommonkey.xmlunit.XMLTestCase;

pubpc class MyXMLTestCase extends XMLTestCase {

   // this test method compare two pieces of the XML
   @Test
   pubpc void testForXMLEquapty() throws Exception {
      String myControlXML = "<msg><uuid>0x00435A8C</uuid></msg>";
      String myTestXML = "<msg><localId>2376</localId></msg>";
      assertXMLEqual("Comparing test xml to control xml", myControlXML, myTestXML);
   }
}

MockObject

In a unit test, mock objects can simulate the behavior of complex, real (non-mock) objects and are therefore useful when a real object is impractical or impossible to incorporate into a unit test.

The common coding style for testing with mock objects is to −

Create instances of mock objects.

Set state and expectations in the mock objects.

Invoke domain code with mock objects as parameters.

Verify consistency in the mock objects.

Given below is an example of MockObject using Jmock.

import org.jmock.Mockery;
import org.jmock.Expectations;

class PubTest extends TestCase {
   Mockery context = new Mockery();
   pubpc void testSubReceivesMessage() {
      // set up
      final Sub sub = context.mock(Sub.class);

      Pub pub = new Pub();
      pub.add(sub);
    
      final String message = "message";
      
      // expectations
      context.checking(new Expectations() {
         oneOf (sub).receive(message);
      });

      // execute
      pub.pubpsh(message);
      
      // verify
      context.assertIsSatisfied();
   }
}