JUnit Annotations 

Introduction on JUnit Annotations

JUnit is one of the most powerful, Java-based and open-source testing framework available free of cost in the market. It helps in easy and quick test case creation and test case execution according to the requirements with the help of annotations. Annotations basically provide extra information about the classes and the methods that are used in the Java code. It helps in performing testing of each and every unit component be it methods, classes, packages, and variables. It is commonly used for Unit testing of applications. The latest upgrade of JUnit is JUnit5. It supports the Selenium web driver for the automation testing of web and mobile applications. org. Junit is the package that contains all the interfaces and classes for testing through JUnit.

JUnit Annotations with Example

Below given are some of the JUnit annotations:

1. @Before

There are scenarios when some test cases or test data needs to be created before the execution of the actual test case. In that case, @Before annotations came into the picture. Annotating any public method with this annotation allows the code/ method to run before every actual @test method. In the case of inheritance, @before methods of the superclass are called first and then the @before methods of the current class.

2. @After

It is just the opposite of @Before annotation. It is used in the cases when some actions need to be performed like releasing of resources, cleaning up memory, printing anything on the console after the execution of @test method (after the execution of every test case). There is one important point that should be noted for @After annotation is that it will execute even in the case when the @test or @before methods throw an exception. In the case of sub and superclass relationship, @after method of subclass/ current class is executed before the @after method of the superclass.

3. @BeforeClass

This annotation is used in the scenarios when some actions need to be performed before the execution of any test case of a particular class like creating a connection with the database, making an entry in a database, entry in the logs, etc. When @BeforeClass annotation is used before any method, that method executes before any test method in a class. Its working is similar to the @Before annotation only difference being that @Before executes the method prior to the execution of every @test method whereas @BeforeClass executes only once, i.e. prior to the execution of any @test method in a Class.

4. @AfterClass

All the resources allocated in the @BeforeClass method needs to be released after the execution of all the @test methods of the current class. This deallocation of resources or any important task that is to be done after the execution of the whole class is done by the @AfterClass method. In simple terms, @AfterClass method runs after all the @test method of the current class is executed. It is executed only once. @AfterClass methods are run mandatory even if the @BeforeClass methods throw an exception.

Like @After method, the working of the @AfterClass method is similar, except the fact that @After method is executed after every @test method of class whereas @AfterClass method is executed once after all the @test methods of a class are executed.

5. @Test

This annotation specifies that the public method under this annotation is a part of the main test case that needs to be executed. The method under the @test defines the test case as passed or failed depending on whether any exception/ error occurs on executing it.

It can also be used in 2 ways:

• @Test(timeout= 500): It takes the parameter as timeout which accepts the values in milliseconds. It considers the test case as failed when it takes longer than the expected time to execute and pass when it executes successfully within the specified time limit.
• @Test(expected= Exception.class): There are situations when we want some methods to throw a specific exception. The test case fails if the method does not throw any exception or the above-mentioned exception.

6. @Ignore

There are scenarios when we want to ignore a few test cases and don’t want to run them. @Ignore helps for the same. Methods under the @Ignore annotations are not executed and are ignored during the execution of the code. Even in the reports generated by TestNG shows the count of test cases that are ignored and the number of test cases passed.

Example

Let’s take an example of JUnit Annotations

package demo;
import org.junit.*;
public class JUnitAnnotationTest {
// Run once, before any @test method in the class are executed
@BeforeClass
public static void bClass() {
System.out.println("BeforeClass method is called”);
}
// Run once after all the @test methods of the class are executed
@AfterClass
public static void aClass() {
System.out.println("AfterClass method is called");
}
// Run before every @test method of a class is executed
@Before
public void bMethod() {
System.out.println("before method is called");
}
// Run after every @test method of class is executed
@After
public void aMethod() {
System.out.println("after method is called");
}
// Test method which has actual test case
@Test
public void testMethod() {
System.out.println("Test method is called");
}
}

 Output:

 Advantages of JUnit Annotations

Below given are some of the advantages of JUnit annotations:

1. JUnit provides an easy way to execute the test cases in a specific way according to the requirements of the user.
2. It is easy to execute the multiple test cases parallelly using the JUnit by combining them in a test suite.
3. JUnit annotations used for automating test cases in Selenium provides very detailed and interactive, graphical report to the user which is very user-friendly too.
4. JUnit allows to pass the parameters in the method using a very simple way.
5. JUnit annotation helps to perform clean coding which is very easy to understand to both testers and programmers.

Conclusion

The above explanation clearly describes the importance of the JUnit framework and the order in which various annotations of JUnit are invoked. It is very important to understand the various annotations before using them in a program so that it will not create any issue in controlling the flow of execution.

Recommended Articles

This is a guide to JUnit Annotations. Here we discuss the introduction and Annotations of JUnit with Example which includes @Before,@After,@Test, and @Ignore, etc. You can also go through our other suggested articles to learn more –

1. Unit Testing
2. White Box Testing
3. Selenium Architecture
4. Test Harness