JUnit Annotations

JUnit Annotations Example

Step 1: Let’s understand this with junit annotations example in java

JunitAnnotationsExample.Java

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 {

    @Test 
    public void m1() { 
        Boolean value = false; 
        assertFalse(value); 
        System.out.println("@Test annotation") 
    } 

    @After 
    public void m1() { 
        list.clear(); 
        System.out.println("@After annotation");
    }

    @Before 
    public void m3() { 
        System.out.println("@Before annotation"); 
    }

    @Ignore 
    public void m4() { 
        System.out.println("@Ignore);// this execution is ignored 
    } 
}

You can also try this code with Online Java Compiler

Run Code

We created a few test methods using the annotations @Test,  @After, @Before, and @Ignore annotations in the above code. It gives the following output. 

Output

@Before annotation 
@Test annotation
@After annotation

1. The test method m3() with @Before annotation gets executed before all the other methods.
2. The method m1() with @Test gets executed and prints the output.
3. The @Ignore annotation ignores the method, so it does not perform the test, and as a result, no output is given by the method. 
4. After all the methods are executed, the @After annotation executes the method m2().

Step 2: Let’s create a testrunner.java class to execute above test:

TestRunner.java

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

Output

Before test
Successful test
After test
Before test
Failing test
After test
Before test
After test
Before test
After test

As we can see, the @Before and @After methods are executed before and after each test, respectively. The @Test methods that are not annotated with @Ignore or @Disabled are executed normally. The @Ignore method is ignored and the @Disabled method is skipped. If a @Test method fails, the exception is caught and printed in the test runner output.

JUnit Assert Class

It is an utility class in JUnit framework used for performing various types of assertions to verify expected results in unit testing. It provides various static methods to compare actual and expected values, throw exceptions based on the outcome of the comparison, and report test failures.

The org.junit.Assert class provides a set of static assertion methods that can be used in JUnit tests to verify expected results. Here are some of the commonly used assertion methods provided by the Assert class:

JUnit Test Cases Class

In JUnit, the TestCase class in the org.junit.TestCase package allows us to run multiple tests. We can mark public void methods as test cases by attaching the @Test annotation to them. The TestCase class provides several methods that are useful for setting up and executing tests, as well as for releasing any resources used during testing.

The org.junit.TestCase class provides several methods that are used to report the results of running JUnit tests. Here are some of the important methods:

JUnit TestResult Class

In JUnit, the TestResult class is used to manage and report the results of a test run. It is part of the org.junit package and provides methods for tracking the number of tests that pass or fail, as well as for reporting on the time taken to run the tests.

The org.junit.TestResult class provides several methods that are used to report the results of running JUnit tests. Here are some of the important methods:

JUnit Test Suite Class

A JUnit test suite class is a Java class that allows you to group multiple JUnit test classes together into a single suite, which can be executed together as a single unit. The purpose of creating a test suite is to organize related tests together and to execute them in a specific order.

The org.junit.TestSuite class provides several methods that are used to report the results of running JUnit tests. Here are some of the important methods:

Check out JUnit Interview Questions here.

Frequently Asked Questions

What are JUnit tests?

A test in JUnit is a method or class used only for testing. These are called  Test methods or Tests classes. The tests contain the code used for testing the behaviour of the application.

What does @Test annotation do?

The @Test annotation indicates that the method or class is a test block, and the code inside it is run to test the code. It helps the JVM recognize the block as a test block and perform the testing on that particular method.

What are annotations in JUnit?

JUnit annotations are predefined texts provided by Java API, which helps the JVM recognize the type of method for testing. The most used annotations like @Test, @Before, @Ignore, etc.

What is @test annotation in JUnit?

The @Test annotation is used in JUnit to mark a method as a test method. When JUnit runs the test class, it looks for methods annotated with @Test and executes them. Test methods typically call methods under test and make assertions about the results.

What are the three basic JUnit annotations?

The three basic JUnit annotations that are commonly used to write test methods: @Test, @Before and @After. By using these annotations, JUnit makes it easy to write and execute test methods in a consistent and repeatable way.

Conclusion

Let's discuss the article in brief for a better understanding.

• The JUnit annotations are predefined texts provided by Java API, which helps JVM to recognize the type of method or class for testing.
• We can install the dependencies necessary for JUnit testing using Maven.
• The most used and valid annotations of JUnit are @Test, @Before, @After, @Ignore, @Disabled, @AfterClass, @Tag, etc.

Hey Ninjas! Don’t stop here; check out Coding Ninjas for more unique courses and guided paths. Also, try Coding Ninjas Studio for more exciting articles, interview experiences, and fantastic Data Structures and Algorithms problems.

Happy Learning!