How To Setup JUnit Environment For Your First Test

JUnit 5 Architecture

JUnit 5 is organized into several modules, divided across three distinct sub-projects, each serving a specific purpose.

JUnit Platform

JUnit Platform is the foundational component for testing frameworks on the Java Virtual Machine (JVM). It provides a standard interface for test discovery and execution, supporting various build tools, IDEs, and test frameworks. It includes the TestEngine API, which allows for creating custom test engines and integrating third-party testing libraries. This architecture enables seamless execution and management of tests across different testing frameworks.

JUnit Jupiter

JUnit Jupiter is the new extension of JUnit. It consists of new annotations and libraries of JUnit 5 to use in the test classes by enhancing capabilities beyond those in JUnit 4. To be more clear, JUnit Jupiter consists of two parts: Jupiter API and Jupiter Engine.

• Jupiter API: It provides a new set of annotations and assertions.
• Jupiter Engine: It helps execute tests written with the Jupiter API.

Junit Vintage

JUnit Vintage provides a Test Engine to run JUnit 4 and JUnit 3 tests, allowing users to run legacy and new tests written with JUnit 5. JUnit Vintage is a supporting library within the JUnit 5 ecosystem to ensure a smooth transition from earlier versions of JUnit.

Follow the video below to learn more about JUnit architecture and how it is better than JUnit 4.

Subscribe to the TestMu AI YouTube Channel to stay updated on video tutorials related to Selenium Java, JUnit testing, and more.

Let’s learn how to setup JUnit further, including the necessary libraries and components for effective use.

How To Install and Setup JUnit?

Here, you will get a step-by-step guide on downloading and setting up JUnit on your machine so you can use it effectively. To do so, let’s start with the pre-requisites:

Installing Java

Installing the Java Development Kit (JDK) is essential to setup JUnit for automation testing. This JDK enables you to code and run Java programs. It is recommended that you install the latest version.

Below are the steps to guide you on installing Java on Windows.

• Go to the Java SE (Standard Edition) page and click JDK Download.
• Accept the license agreement to download the JDK executable file.
• Double-click on the installer executable to begin the installation process. After installation, the JDK will be located in Program Files > Java > JDK-22 (or a similar directory, depending on your installed version).
• Upon installation of Java, you must append the installation location to the environment variables PATH and CLASSPATH.
• Search for Environment Variables in your system and select Edit the system environment variables.
• Click the Advanced tab in the System Properties window, then click the Environment Variables… button.
• Under System Variables, click New.
• Under the Variable name, enter JAVA_HOME, and for the Variable value, enter the path where your JDK is stored. Click the OK button to save the entries.
• The last step is to verify if the installation of Java on the machine was successful. To do so, run the command java version to verify it.

You have successfully setup Java on your machine by following the steps above. Next, let’s proceed to setup the JUnit environment variable.

Setting JUnit Environment Variable

Here, you will learn two key aspects: installing JUnit and setting up its environment variables.

Follow the steps below to complete the setup of JUnit on your machine, including downloading and installing JUnit 5.

• Go to the JUnit 5 releases page on Maven Central or the JUnit official website.
• Download the latest version of JUnit 5. You’ll typically need the following JAR files:
• junit-jupiter-api
• junit-jupiter-engine
• junit-platform-launcher

You can add JUnit 5 to your project using a build tool like Maven or Gradle, which will handle your dependencies.

• Click on junit.jar to redirect to the Maven Central repository, where you can download the JUnit jar file.
• In the Maven Central Repository, click on the latest version of the JUnit framework (recommended latest).

This will open a page where you can download the JUnit JAR file and view options to download the dependencies for inclusion in pom.xml. Since we are manually downloading the JUnit JAR, you must include this JAR file in your pom.xml.

Alternatively, you can download the JUnit JAR file directly from the Maven repository using this JAR file and save the JUnit JAR file in a designated location, such as C:\JUnit.

• Download the Hamcrest (v2.2) JAR file from the Maven repository. The Hamcrest core jar file is now obsolete. Instead, a single Hamcrest jar file has to be downloaded so that you can execute the JUnit tests in Eclipse, IntelliJ, and on the command line.

So far, we have downloaded two jar files (JUnit and Hamcrest) on our system. The files are placed in the C:\JUnit folder directory.

Now that you have completed the setup for JUnit along with the required libraries, the next step is to configure the necessary environment variables for accessing the JUnit framework.

To setup the JUnit environment variable on your machine, follow the same steps you used for setting up the Java environment variable.

Below are the steps for setting up JUnit environment variables.

• Search for Environment Variables on Windows.
• In the System Properties window, click on Environment Variables…
• Under the System Variables section, click New.
• Enter JUNIT_HOME for the Variable name and the path where JUnit is stored for the Variable value.
• Click OK to save the new environment variable.

Great, you have completed the setup of JUnit on your machine. Next, learn to configure and use JUnit in an IDE like IntelliJ.

How To Use JUnit With IntelliJ IDEA?

IntelliJ IDEA is a popular cross-platform Integrated Development Environment (IDE) developed by JetBrains. It supports Java, Kotlin, Scala, Groovy, and various other languages through plugins, including PHP, Python, Ruby, and JavaScript. IntelliJ IDEA is suitable for various development needs and is available in an Apache-licensed Community Edition and a proprietary Commercial Edition.

Setting IntelliJ IDEA Environment

Once you’ve completed the setup of JUnit on your machine, you can leverage IntelliJ IDEA to write and manage more complex test code. This IDE simplifies using the JUnit framework, allowing you to write, execute, and manage your tests efficiently.

To get started, follow these steps for the setup of JUnit in IntelliJ:

• Create a new Maven project in IntelliJ and select the project SDK.
• Name your project JUnit Demo.
• If multiple Java SDK versions are installed on your system, you can choose the desired Java SDK for your project.
• Right-click on your project and select Open Module Settings.
• Under Project Settings, click on Project.
• Select the Java SDK version “22” in the Project SDK dropdown.
• Click OK to apply the changes.
• Once the project structure is ready, you can create a new package in \src\test\java.
• You can name the package com.test.junitdemo.
• Right-click on the newly created package (e.g., com.test.junitdemo) and select New > Java Class to create a new Java class.

Alternatively, If you’re using Maven or Gradle, add JUnit dependencies to your pom.xml or build.gradle file respectively.

For Maven:

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.8.2</version> <!-- Use the latest version -->
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.8.2</version> <!-- Use the latest version -->
        <scope>test</scope>
    </dependency>
</dependencies>

For Gradle:

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2' // Use the latest version
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2' // Use the latest version
}

Note: If not using a build tool, download the JUnit JAR files and add them to your project’s classpath.

Creating Your First JUnit Test

After completing the setup of JUnit, it is time to create your first test. Writing a basic code will help you understand how JUnit works and validate that your setup is correct.

The below class has a method that converts Fahrenheit to Celsius.

package com.lambdatest.junit;


public class Class1 {


    public double conversion(double temparature, String unit){
        if(unit.equals("F")){
            return (temparature-32)*(5.0/9.0);
        }else{
            return (temparature *(9.0/5.0))+32;
        }
    }
}

Now, let us write the simple JUnit test class to test the conversion() in Class 1.

package com.lambdatest.junit;


import org.junit.Test;


import static junit.framework.Assert.assertEquals;


public class JunitTestClass1 {


    @Test
    public void testconversion(){
        //Given
        Class1 classunderTest=new Class1();
        //When
        double temparature=80.0d;
        String unit="";
        double result = classunderTest.conversion(temparature, unit);
        //Then
        //assertions
        assertEquals(170.00d,result,0.0);
    }
}

The JUnit annotation @Test tells JUnit that the public void method it is attached to can be run as a test case.

We split the JUnit test class into three parts: Given, When, and Then.

• Given: you can create and initialize a new class instance under test.
• When: you can setup the variables that need to be passed when calling the method under test. If the method returns a value, it must be captured in a variable for assertion.
• Then: you can assert that the actual value matches the expected value using the assertEquals(expected, actual, delta) method.

Here:

• expected is the value specified for comparison.
• actual is the value returned by the method being tested.
• delta is the margin of error for the comparison for validating floating-point values.

To learn more about JUnit assertion, watch the video below and get detailed insights.

Setting JUnit in IntelliJ IDEA

There are two ways to setup JUnit on IntelliJ IDEA:

• Adding local dependencies (to add JUnit, Hamcrest, and other relevant dependencies)
  You can specify the paths to local dependencies (e.g., JUnit and Hamcrest) in the pom.xml file. If you have used pom.xml in Eclipse, you can use the same file in IntelliJ IDEA without any modifications.

Here is an example snippet from pom.xml showing how to include local dependencies:

<dependencies>
    [...]
    <dependency>
        <groupId>hamcrest</groupId>
        <artifactId>hamcrest</artifactId>
        <version>2.2</version>
        <scope>system</scope>
        <systemPath>C:JUnithamcrest-2.2.jar</systemPath>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.1</version>
        <scope>system</scope>
        <systemPath>C:JUnitjunit.jar</systemPath>
    </dependency>
    [...]
</dependencies>

Double-click on any JUnit import statement to verify that the local dependencies are correctly included (e.g., import org.junit.AfterClass;). This will confirm if the local dependencies are fulfilled as specified in the pom.xml.

• Installing JUnit jar in IntelliJ as External Jar
  If you prefer not to use pom.xml, add local dependencies through the IntelliJ IDEA GUI. Dependencies are libraries on which the module depends, such as JUnit and Hamcrest.

Dependencies can be added at three levels in IntelliJ IDEA:

• Global – Available for many projects
• Module – Available for a specific module
• Project – Available for all modules within a project

To install JUnit and Hamcrest JAR files as external libraries at the ‘Project Level’:

• Right-click on the project or go to File > Project Structure in the menu and select Open Module Settings.
• In the Project Settings window, select Libraries. Click the + button and choose Java.
• Navigate to the path containing the JUnit and Hamcrest JAR files. Select these files and click OK.
• The JAR files will be added as External Libraries to the project.
• To verify the successful addition of External Libraries, double-click on any JUnit import statement (e.g., import org.junit.AfterClass;). You will see that it refers to the JUnit JAR included as an External Library in the project.

With the above steps, you have completed the setup of JUnit in IntelliJ. Now, let’s learn how to execute your JUnit tests within the IntelliJ platform.

Executing JUnit Tests in IntelliJ IDEA

To run JUnit tests in IntelliJ IDEA, follow the below steps:

• Right-click on the project and select Run ‘All Tests.’
• You can also run JUnit tests by right-clicking a particular test (e.g., JUnitDemo) and clicking Run ‘TestName’ (e.g., Run JUnitDemoClass).

JUnit 5 supports parallel execution of tests, which speeds up the execution of the test suite when there are a large number of tests. There are two ways to achieve parallel execution in JUnit 5: at the class and method levels. Below, you can see how to configure parallel execution for both approaches.

• Class level: To achieve parallel execution at the class level, you must set the properties below in the junit-platform.properties file.
• Method Level: To run specific test methods in parallel within the same class, apply the @Execution annotation at the method level.

Executing JUnit Tests in IntelliJ IDEA

<properties>
    <junit.jupiter.execution.parallel.enabled>true</junit.jupiter.execution.parallel.enabled>
</properties>

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.parallel.Execution;
import org.junit.jupiter.api.parallel.ExecutionMode;
class ParallelMethodTest {
    @Test
    @Execution(ExecutionMode.CONCURRENT)
    void test1() {
        // test logic
    }
}

• Open the browser and navigate to TestMu AI eCommerce Playground.
• Maximize the browser window.
• Locate the search input field and enter “iPhone.”
• Click on the search button.
• Verify that the page title is “Search iphone.”

package com.test.junitdemo;




import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.parallel.Execution;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.remote.RemoteWebDriver;




import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import static org.junit.jupiter.api.parallel.ExecutionMode.CONCURRENT;




@Execution(CONCURRENT)
public class JUnitDemoClass {








    public String username = "username";
    public String accesskey = "access_key";




    public static RemoteWebDriver driver;
    public String gridURL = "@hub.lambdatest.com/wd/hub";
    boolean status = false;
    static String URL = "https://ecommerce-playground.lambdatest.io/";




    @Before
    public void setup() throws MalformedURLException {




        String hub = "@hub.lambdatest.com/wd/hub";




        ChromeOptions browserOptions = new ChromeOptions();
        browserOptions.setPlatformName("Windows 11");
        browserOptions.setBrowserVersion("126.0");
        HashMap<String, Object> ltOptions = new HashMap<String, Object>();
        ltOptions.put("username", "username");
        ltOptions.put("accessKey", "acceeskey");
        ltOptions.put("project", "Junit Test");
        ltOptions.put("w3c", true);
        ltOptions.put("plugin", "java-testNG");
        browserOptions.setCapability("LT:Options", ltOptions);
        try {
            driver = new RemoteWebDriver(new URL("https://" + username + ":" + accesskey + gridURL), browserOptions);
        } catch (MalformedURLException e) {
            System.out.println("Invalid grid URL");
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }








    }












    @Test
    public void test_() throws InterruptedException {




        System.out.println(Thread.currentThread().getName());
        driver.navigate().to(URL);
        driver.manage().window().maximize();








        try {




            driver.findElement(By.xpath("(//input[@placeholder='Search For Products'])[1]")).sendKeys("iPhone");
            driver.findElement(By.xpath("//button[normalize-space()='Search']")).click();




            String actualTitle = driver.getTitle();
            Assert.assertEquals(actualTitle, "Search IPhone");
            if (actualTitle.equals("Search-iphone")) {
                System.out.println("Demonstration of running JUnit tests is complete");
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }




    @Test
    public void first() throws Exception{
        System.out.println("FirstParallelUnitTest first() start => " + Thread.currentThread().getName());
        Thread.sleep(500);
        System.out.println("FirstParallelUnitTest first() end => " + Thread.currentThread().getName());
    }




    @Test
    public void second() throws Exception{
        System.out.println("FirstParallelUnitTest second() start => " + Thread.currentThread().getName());
        Thread.sleep(500);
        System.out.println("FirstParallelUnitTest second() end => " + Thread.currentThread().getName());
    }




    @Test
    public void test_1() throws InterruptedException {
        System.out.println(Thread.currentThread().getName());
        driver.navigate().to(URL);
        driver.manage().window().maximize();




        try {




            driver.findElement(By.xpath("(//input[@placeholder='Search For Products'])[1]")).sendKeys("iPhone");
            driver.findElement(By.xpath("//button[normalize-space()='Search']")).click();




            String actualTitle = driver.getTitle();
            Assert.assertEquals(actualTitle, "Search IPhone");
            if (actualTitle.equals("Search-iphone")) {
                System.out.println("Demonstration of running JUnit tests is complete");
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }



    @After
    public void tearDown() {




        driver.quit();
    }


}

junit.jupiter.execution.parallel.config.strategy=fixed
junit.jupiter.execution.parallel.config.fixed.parallelism=4