JUnit 5 – @RepeatedTest

JUnit 5 is a widely used testing framework in the Java ecosystem. It is the successor of JUnit 4 and is designed to address its limitations. JUnit framework allows the developers to write and run the tests for their Java code. These tests help ensure that the code functions correctly and continues to work as expected as changes are made. JUnit 5 provides a variety of annotations and one such annotation is `@RepeatedTest`. In this article, let us understand about @RepeatedTest annotation in JUnit 5.

Prerequisites

To understand this, we need to have some prerequisites.

• It is essential to have knowledge of at least Java version 8.
• Understanding of build management tools like Maven or Gradle.
• Java Integrated Development Environment (IDE) such as Eclipse, IntelliJ IDEA, or Visual Studio Code.

@RepeatedTest in JUnit 5

@RepeatedTest annotation is used in JUnit 5 in order to specify the number of times the test method should execute. This annotation is used to measure the Robustness of a specific test case.

Syntax of @RepeatedTest

@RepeatedTest (value, name)

Where,

• value: It represents the number of times the test must execute repeatedly.
• name (optional): It represents the display name for every time the test executes.

IDE Setup for Implementing @RepeatedTest( Step By Step Implementation)

Here, we are using Eclipse IDE for Java and Web Developers. You may also use other platforms like IntelliJ, Spring suite tool, Spring Initializer, etc.

Step 1: Creation of Project

• Go to the `file` menu and click new and navigate to `Spring Starters project`. If you don’t find the Spring Starters project immediately after `new`, then click other and find `Spring Starters project`.
• File > new > Spring Starters project.

• Name your project and configure the default options given if necessary.

Project type: Maven
Packaging: Jar
Java Version: 8
Language: Java

• Make sure that, you have chosen the type as ‘Maven‘ and the version of Java should be at least 8.
• Add dependencies If you need any, otherwise, click `finish`.

Step 2: Adding dependencies

Let us configure our `pom.xml` file with the following dependencies:

JUnit Jupiter API:

The JUnit Jupiter API is the part of JUnit 5 framework which provides annotations, assertions, and other features for defining and running test cases and serves as a programming model for writing tests in Java. To add the JUnit Jupiter API in pom.xml file, copy and paste the following code.

XML

<dependency>
     <groupId>org.junit.jupiter</groupId>
     <artifactId>junit-jupiter-api</artifactId>
     <version>5.8.0</version>
     <scope>test</scope>
</dependency>

Project Setup for Application

Now, that the project setup is ready, let us look into an example to understand how to write and run test cases of JUnit using the Maven tool.

Step 1: Create a new package in the `src/test/java`, right-click on `src/test/java` > new > package.

Step 2: Create a class in the package and name it as per your requirement. i.e. `Addition`. To create a class, right-click on package > new > class

Step 3: Write the logic which you want to test in `Addition.java`.

Java

//Java code to demonstrate addition operation
package project;

public class Addition {
    public int sum(int a, int b) {
        return a+b;
    }
}

Step 4: Now, create a test case inside the package by right click on the package > new > others > java > JUnit > JUnit test case.

Example for Test Case1

Test Script: Let us write the first test case i.e. `Testcase1`.

Java

package project;

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.RepeatedTest;

class Testcase1 {

    @RepeatedTest(3)
    public void test1() {
        Addition addition = new Addition();
        int actual = addition.sum(2, 3);
        int expected = 5;
        assertEquals(actual, expected);
        System.out.println("Test executed");
    }
}

Steps to run the Application

To run the application, Go to project explorer > right click on your project > Run as > Spring Boot App.

Output of the above Program

JUnit view:

Console view:

Explanation of the Above Program:

In the above code snippet, the `Testcase1` is annotated with `@RepeatedTest()` along with the `value` as `3` representing that the test should execute 3 times. we have defined the `test1` method in which we have created the `addition` object for `Addition.java` and calculated the sum and stored in `actual` variable. We have asserted the result by comparing the `actual` and `expected` values with `assertEquals` method.

Example for Test Case2

Test Script: Let us write the first test case i.e. `Testcase2`.

Java

package project;

import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.RepeatedTest;

class Testcase2 {

    @RepeatedTest(value=3, name="Test run {currentRepetition} of {totalRepetitions}")
    public void test1() {
        Addition addition = new Addition();
        int actual = addition.sum(2, 3);
        int expected = 5;
        assertEquals(actual, expected);
        System.out.println("Test executed");

    }
}

Output of JUnit 5 Program

JUnit view:

Console view:

Explanation of the above Program:

In the above code snippet, the `Testcase2` is annotated with `@RepeatedTest()` along with the `value` as `3` and `name` as `Test run {currentRepetition} of {totalRepetitions}` representing that the test should execute 3 times and displaying the current and total repeatition values. we have defined the `test1` method in which we have created the `addition` object for `Addition.java` and calculated the sum and stored in `actual` variable. We have asserted the result by comparing the `actual` and `expected` values with `assertEquals` method.