JUnit Annotations Tutorial with Example: What is @Test and @After

What is JUnit Annotations?

JUnit annotations are a special form of syntactic meta-data that can be added to Java source code for better code readability and structure. Variables, parameters, packages, methods and classes can be annotated. Annotations were introduced in JUnit 4, which makes Java code more readable and simple. This is the big difference between JUnit 3 and JUnit 4: JUnit 4 is annotation based.

With a working knowledge of these annotations, one can easily learn and implement a JUnit test. Below is the important and frequently used JUnit annotations list, with the JUnit 5 (Jupiter) equivalent beside each one:

JUnit Annotations Example

Let’s create a class covering important JUnit annotations with simple print statements and execute it with a test runner class:

Step 1) Consider the below Java class having various methods which are attached to the above-listed annotations:

JunitAnnotationsExample.java

package guru99.junit;		

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

import java.util.ArrayList;		

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

public class JunitAnnotationsExample {				

    private ArrayList<String> list;					

    @BeforeClass		
    public static void m1() {							
        System.out.println("Using @BeforeClass , executed before all test cases ");					
    }		

    @Before		
    public void m2() {					
        list = new ArrayList<String>();					
        System.out.println("Using @Before annotations ,executed before each test cases ");					
    }		

    @AfterClass		
    public static void m3() {							
        System.out.println("Using @AfterClass ,executed after all test cases");					
    }		

    @After		
    public void m4() {					
        list.clear();			
        System.out.println("Using @After ,executed after each test cases");					
    }		

    @Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }		

    @Ignore		
    public void m6() {					
        System.out.println("Using @Ignore , this execution is ignored");					
    }		

    @Test(timeout = 10)			
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }		

    @Test(expected = NoSuchMethodException.class)					
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					

    }		

}		

Step 2) Let’s create a test runner class to execute the above test:

TestRunner.java

package guru99.junit;		

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(JunitAnnotationsExample.class);					
			for (Failure failure : result.getFailures()) {							
         System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

Expected Result

• All the test cases will be executed one by one, and all print statements can be seen on a console.
• As discussed in the above table, @Before and @BeforeClass in JUnit [ methods m2() and m1() ] will be executed before each test case and before all test cases respectively.
• In the same way @After and @AfterClass in JUnit (methods m4() and m3()) will be executed after each test case and after all test cases respectively. @Ignore (method m6()) will be treated as ignoring the test.

Let’s analyse the test cases used in the above Java class in detail:

1. Consider method m5() as given below:

	@Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }		

In the above method, as you are adding a string to the variable “list”:

• list.isEmpty() will return false.
• assertFalse(list.isEmpty()) must return true.
• As a result, the test case will pass.

As you have added only one string to the list, the size is one.

• list.size() must return the int value “1”.
• So assertEquals(1, list.size()) must return true.
• As a result, the test case will pass.

2. Consider method m7() as given below:

@Test(timeout = 10)		
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }		

As discussed above, @Test(timeout = 10) is used to enforce a timeout in the test case. The value is in milliseconds, so m7() must finish within 10 ms.

3. Consider method m8() as given below:

@Test(expected = NoSuchMethodException.class)				
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					
    
    }		

As discussed above, @Test(expected) will check for the specified exception during its execution, so method m8() will throw “No Such Method Exception.” As a result, the test will be executed with an exception.

Accuracy note: m8() only prints a line, so the declared exception is never actually thrown and JUnit 4 reports the test as failed. Align the expected type with what the method really throws. JUnit 5 writes this with assertThrows.

As all test cases are passed, this results in a successful test execution.

Actual Result

As there are three test cases in the above example, all test cases will be executed one by one. See the console screenshot below:

See below print statements which can be seen on console:

Using @BeforeClass , executed before all test cases

Using @Before annotations, executed before each test cases

Using @After, executed after each test cases

Using @Before annotations, executed before each test cases

Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case

Using @After, executed after each test cases

Using @Before annotations, executed before each test cases

Using @Test(expected) ,it will check for specified exception during its execution

Using @After, executed after each test cases

Using @AfterClass, executed after all test cases

JUnit Assert Class

The annotations decide when a method runs; the assert methods decide whether it passes.

This class provides a bunch of assertion methods useful in writing a test case. If all assert statements are passed, test results are successful. If any assert statement fails, test results are failed. The dedicated JUnit assert tutorial covers each method in depth.

As you have seen earlier, the below table describes important Assert methods and their description:

JUnit Test Cases Class

To run multiple tests, the TestCase class is available in the junit.framework package. The @Test annotation tells JUnit that this public void method (a test case here) to which it is attached can be run as a test case.

Version note: TestCase, TestResult and TestSuite belong to the legacy junit.framework package from JUnit 3. They still ship inside the junit 4.x artifact, but annotation-based tests do not extend TestCase.

The below table shows some important methods available in the junit.framework.TestCase class:

JUnit TestResult Class

When you execute a test, it returns a result (in the form of a TestResult object). This TestResult object can be used to analyse the resultant object. This test result can be either failure or successful.

See the below table for important methods used in the junit.framework.TestResult class:

JUnit Test Suite Class

If you want to execute multiple tests in a specified order, it can be done by combining all the tests in one place. This place is called a test suite, and the JUnit test suite tutorial walks through a full example.

See the below table for important methods used in the junit.framework.TestSuite class:

FAQs