Effective Java Unit Testing Guide

Do you ever write a complex piece of code and think you’ve got it right but aren’t completely certain? This is where unit tests come in to verify that your code is functioning correctly. This means testing every part of your code to ensure it works as expected.

You can use the JUnit testing framework to create unit tests and verify your Java code, and we will show you exactly how to do this. In this article, we will discuss a step-by-step guide on how to test your code efficiently and execute Java unit testing. Let’s first discuss what unit testing is and why it’s important in general. 

 What is Unit Testing?

Unit testing involves checking each component of your code to verify if they function as expected. It isolates individual methods and conducts tests on them. This process ensures that your software works correctly before it’s released. As a developer, you should write unit tests immediately after writing a piece of code. 

Typically, when working with Java, that particular piece of code is often a class or even a method within a class. Unit tests then become the Java code that you create to target and check that specific method, ensuring it performs as expected.

Why Use JUnit for Java Unit Testing

With unit testing becoming more prevalent, various frameworks supporting Java unit testing have gained popularity. Java testing frameworks such as JUnit, TestNG, etc, outline the guidelines for test scripts, define the basic structure of tests, and provide a strategy for your testing cycle. JUnit, in particular, is the standard framework for unit testing in Java applications.

Why use JUnit for unit testing Java applications? JUnit allows you to efficiently write unit tests to identify and fix bugs in your code early. Using JUnit can speed up development by finding issues early and frequently, helping you deliver higher-quality code faster. It’s also commonly used for test-driven development (TDD), so if you’re aiming to practice TDD, you’ll likely encounter JUnit and need to master its use.

Now, let us see how to test the code by executing the Java Unit testing example using JUnit. 

Java Unit Testing-How to Test Your Code 

We will be discussing the steps to test the code, so let us assume that we have already developed Java code that requires to be tested. Here is the Java Unit testing example: 

Java Unit Code to be Tested

To write unit tests for the Calculator class in a separate file, you can use a testing framework like JUnit. Below, we will show you how to set up a Calculator.java file and a TestCalculator.java file with unit tests for the add and subtract methods.

First, you have to ensure JUnit is set up in your project. If you're using a build tool like Maven or Gradle, add JUnit as a dependency. 

Here's the Calculator.java file:

// Calculator.java
public class Calculator {
    // Method to add two integers
    public int add(int a, int b) {
        return a + b;
    }


    // Method to subtract two integers
    public int subtract(int a, int b) {
        return a - b;
    }
}

Assertions class should be used to validate the expected results of your tests. Common assertions include:

• ‘assertEquals(expected, actual)’: Verifies if two values are identical.

• ‘assertTrue(condition)’: Ensures a specified condition evaluates to true.

• ‘assertFalse(condition)’: Ensures a specified condition evaluates to false.

• ‘assertNotNull(object)’: Checks that an object reference is not null.

• ‘assertNull(object)’: Checks that an object reference is null

Now, you have to create the TestCalculator.java file for the unit test in the same code directory where Calculator.java file is present to demonstrate these assertions in action:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;


public class TestCalculator {


    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(10, 5);
        assertEquals(15, result, "10 + 5 should equal 15");
    }


    @Test
    public void testSubtract() {
        Calculator calculator = new Calculator();
        int result = calculator.subtract(10, 5);
        assertEquals(5, result, "10 - 5 should equal 5");
    }


    @Test
    public void testAddNegative() {
        Calculator calculator = new Calculator();
        int result = calculator.add(-10, -5);
        assertEquals(-15, result, "-10 + (-5) should equal -15");
    }
}

Instructions to Run the Tests

• You have to ensure JUnit is in Your Classpath:

Say for example you are using Maven, you have to create pom.xml file in the same code directory where Calculator.java and TestCalculator.java are present. Now, add the following dependency to your  pom.xml

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.7.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-engine</artifactId>
        <version>5.7.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Or else, if you are using Gradle, you have to create build.gradle file in the same code directory where Calculator.java and TestCalculator.java are present. You have to add the following to your build.gradle

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
}

• Next, you have to compile and run the code: You have to navigate to the code directory in your terminal and run the following commands:

For Maven:

cd code
mvn compile
mvn test

For Gradle:

cd code
gradle build
gradle test

When you are following the above-mentioned steps, Maven and Gradle will manage the classpath for you, including the JUnit dependencies, so you don't have to manually specify paths to the JUnit jars.

Analysis of the Test Result

Suppose, after running mvn test, you see an output similar to the following in the terminal:

For Maven:

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running TestCalculator
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.032 s - in TestCalculator


Results :
Tests run: 3, Failures: 0, Errors: 0, Skipped: 0

Analysis of the above test result:

• Tests Run: Maven executed 3 tests (testAdd, testSubtract, testAddNegative).

• Failures: Maven reports Failures: 0, indicating all tests passed successfully.

• Errors: Similarly, Errors: 0 shows there were no unexpected errors during test execution.

For Gradle:

After running gradle test, you see an output similar to the following in the terminal.

BUILD SUCCESSFUL in 1s
3 actionable tasks: 3 executed

Further, Gradle generates HTML reports that you can view in a web browser. These reports are typically located in:

build/reports/tests/test/index.html

Open the index.html file in a web browser to view the test reports. Below is the screenshot of the index.html page for reference.

The above HTML test report generated by Gradle will give you detailed information about your test suite, including:

• Test Summary: The total tests run, passed, failed, and skipped.

• Detailed Test Results: Detailed breakdown of each test method with status (passed, failed, error), duration, and any error messages or stack traces.

• Test Suite Overview: Visual representation (if available) of test results, often in the form of charts or graphs.

• Configuration Details: Information about the environment, build configuration, and system properties during testing.