How to Perform Java Unit Testing With JUnit

Why Use JUnit for Unit Testing?

JUnit is the default testing framework for Java. It’s lightweight, extensible, and supported by every major IDE and CI/CD tool.

Features:

• Annotations: JUnit annotations like @Test, @BeforeEach, and @AfterAll to define test structure. It keeps your tests readable and easy to maintain.
• Built-In Assertions: JUnit assertions provide methods like assertEquals(), assertThrows(), and assertNotNull() to verify small units of logic precisely.
• Parameterization: JUnit parameterized tests let you run the same test with different input values using the @ParameterizedTest annotation, helping validate a unit under various conditions.
• Mocking and Dependency Injection: Works with mocking frameworks (like Mockito), making it easier to isolate and test units without relying on actual dependencies.

If you are getting started with JUnit, we recommend checking out this JUnit tutorial.

Setting Up a Project

To get started, make sure you have the following:

• An IDE, such as IntelliJ IDEA or Eclipse, to write and perform Java unit testing.
• Install Java JDK 8 or above version.
• Set up a build tool such as Maven or Gradle.

Maven: To use Maven, add the following to the pom.xml file:

<dependencies>
  <dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.8.2</version>
    <scope>test</scope>
  </dependency>
</dependencies>

Gradle: For Gradle, add the following to the build.gradle file:

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
}

test {
    useJUnitPlatform()
}

Writing Your First Unit Test

Let’s walk through the process of writing a basic unit test in Java.

Test Scenario:

Verify that a basic calculator performs arithmetic operations: addition, subtraction, multiplication, and division.

Here’s the Calculator class:

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    public int subtract(int a, int b) {
        return a - b;
    }
    public double divide(int a, int b) {
        if (b == 0) throw new IllegalArgumentException("Cannot divide by zero");
        return (double) a / b;
    }
}

Implementation:

Let’s write unit tests to verify the basic arithmetic operations (addition, subtraction, multiplication, and division). It includes edge cases like zero and negative numbers and ensures exceptions are thrown for invalid operations like division by zero.

@DisplayName("Calculator Tests")
class CalculatorTest {
    private final Calculator calculator = new Calculator();

    @Test
    @DisplayName("Test addition with zero")
    void testAddWithZero() {
        assertEquals(5, calculator.add(5, 0));
        assertEquals(5, calculator.add(0, 5));
        assertEquals(0, calculator.add(0, 0));
    }

    @Test
    @DisplayName("Test addition with negative numbers")
    void testAddWithNegativeNumbers() {
        assertEquals(-8, calculator.add(-5, -3));
        assertEquals(2, calculator.add(5, -3));
        assertEquals(-2, calculator.add(-5, 3));
    }

    @Test
    @DisplayName("Test subtraction with zero")
    void testSubtractWithZero() {
        assertEquals(5, calculator.subtract(5, 0));
        assertEquals(-5, calculator.subtract(0, 5));
        assertEquals(0, calculator.subtract(0, 0));
    }

    @Test
    @DisplayName("Test subtraction with negative numbers")
    void testSubtractWithNegativeNumbers() {
        assertEquals(-2, calculator.subtract(-5, -3));
        assertEquals(8, calculator.subtract(5, -3));


        assertEquals(-8, calculator.subtract(-5, 3));
    }

    @Test
    @DisplayName("Test multiplication with zero")
    void testMultiplyWithZero() {
        assertEquals(0, calculator.multiply(5, 0));
        assertEquals(0, calculator.multiply(0, 5));
        assertEquals(0, calculator.multiply(0, 0));
    }

    @Test
    @DisplayName("Test multiplication with negative numbers")
    void testMultiplyWithNegativeNumbers() {
        assertEquals(15, calculator.multiply(-5, -3));
        assertEquals(-15, calculator.multiply(5, -3));
        assertEquals(-15, calculator.multiply(-5, 3));
    }

    @Test
    @DisplayName("Test division by zero")
    void testDivideByZero() {
        assertThrows(IllegalArgumentException.class, () -> calculator.divide(5, 0));
    }

    @Test
    @DisplayName("Test division with zero numerator")
    void testDivideWithZeroNumerator() {
        assertEquals(0.0, calculator.divide(0, 5));
    }

    @Test
    @DisplayName("Test division with negative numbers")
    void testDivideWithNegativeNumbers() {
        assertEquals(1.6666666666666667, calculator.divide(-5, -3));
        assertEquals(-1.6666666666666667, calculator.divide(5, -3));
        assertEquals(-1.6666666666666667, calculator.divide(-5, 3));
    }
}

Code Walkthrough:

• The CalculatorTest class uses JUnit 5 annotations to test basic arithmetic operations: addition, subtraction, multiplication, and division using a Calculator object. Each method checks correctness using assertEquals or assertThrows.
• The tests cover edge scenarios such as operations with zero, negative numbers, and division by zero. These ensure the calculator behaves correctly under various common and boundary conditions.
• Each test method is annotated with @DisplayName for clearer reporting. The tests are grouped logically, making the suite well-structured and easy to maintain or expand.

Test Execution:

Run the below command to execute the test:

mvn test -Dtest=CalculatorTest

Performing JUnit Testing With Selenium

While unit tests validate your logic in isolation, they don’t ensure that your web application behaves as intended across browsers. That’s where UI testing comes in.

By using Selenium, you can simulate user interactions, and with JUnit, you get features like annotations and assertions for structuring and executing test cases. When combining Selenium with JUnit, you can automate your tests across browsers to ensure your web application behaves as intended at the user interface level.

Test Scenario:

• Go to the Simple Form Demo page of TestMu AI Selenium Playground.
• Enter the first and second values in the form.
• Click on the Get Sum button.
• Verify that the correct sum is displayed.

Implementation:

To run this test, make sure you’ve added the following Selenium dependency in your pom.xml file:

<dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>4.15.0</version>
</dependency>

Below is the test script that uses Selenium to automate the behavior of a simple calculator UI.

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@DisplayName("Calculator Addition Tests")
public class LocalSeleniumCalculatorTest {
    private WebDriver driver;

    @BeforeAll
    void setUp() {
        driver = new ChromeDriver();
        driver.manage().window().maximize();
    }

  @AfterAll
    void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }

    @ParameterizedTest(name = "Test Case {index}: {0} + {1} = {2}")
    @CsvSource({
        "5, 7, 12",
        "1, 1, 2",
        "-2, 3, 1",
        "100, 200, 300",
        "1000000, 2000000, 3000000",
        "999999, 1, 1000000",
        "abc, def, Entered value is not a number",
        "xyz, 123, Entered value is not a number",
        "2147483647, 1, 2147483648",
        "'', '', Entered value is not a number",
        "' ', ' ', Entered value is not a number"
    })
    @DisplayName("Test calculator addition with various inputs")
    void testAddition(String a, String b, String expected) {
        driver.get(TestConfig.APP_URL);
        WebElement firstInput = driver.findElement(By.id("sum1"));
        WebElement secondInput = driver.findElement(By.id("sum2"));
        WebElement getSumButton = driver.findElement(By.xpath("//button[text()='Get Sum']"));

        firstInput.clear();
        firstInput.sendKeys(a);
        secondInput.clear();
        secondInput.sendKeys(b);
        getSumButton.click();

        WebElement result = driver.findElement(By.id("addmessage"));
        assertEquals(expected, result.getText());
    }
}

Code Walkthrough:

• The @BeforeAll annotation sets up the ChromeDriver and maximizes the browser window before any test runs. Since this method only runs once for the entire class, the @TestInstance(TestInstance.Lifecycle.PER_CLASS) annotation allows us to use non-static setup methods.
• After all tests finish, the @AfterAll annotation ensures the browser is closed. The @ParameterizedTest annotation allows this single test method to run multiple times, each with a different set of input values.
• The @CsvSource annotation provides these combinations. The name field ensures each test case is labeled clearly in reports, showing the inputs and expected output.
• The testAddition() method navigates to the calculator web app and inputs the values into the calculator’s fields. It clicks the “Get Sum” button, retrieves the result, and asserts that the displayed result matches the expected output.

Test Execution:

Run the below command to execute the test:

mvn test -Dtest=LocalSeleniumCalculatorTest

Running UI tests locally is a great starting point. However, to catch layout bugs, inconsistent DOM behavior, and platform-specific quirks, you need cross-browser testing, and that’s where TestMu AI comes in.

TestMu AI is a GenAI-native test execution platform that provides an online Selenium Grid to run JUnit tests across multiple browsers and OS combinations without maintaining your infrastructure.

To get started, check out this documentation on JUnit testing on TestMu AI.

To run Selenium JUnit tests on TestMu AI instead of your local machine, you need to replace the local WebDriver instance with a RemoteWebDriver that connects to TestMu AI cloud Selenium Grid using the URL https://:@hub.lambdatest.com/wd/hub.

After that, you need to configure Selenium automation capabilities to define the browser, version, platform, and other settings.

You can generate these capabilities from the TestMu AI Automation Capabilities Generator.

Test Execution:

Run the below command to execute the test:

mvn test -Dtest=CloudCalculatorTest

Best Practices for Java Unit Testing

Here are some of the best practices you can follow while performing Java unit testing:

• Use Clear and Descriptive Test Names: Avoid vague names like test1. A method like testDivideByZeroThrowsException() immediately conveys intent.
• Write Focused and Isolated Tests: Each test should cover one behavior or scenario. This keeps failures easy to trace and reduces false positives from unrelated changes.
• Test Both Success and Failure Paths: Don’t just test the happy path. If your code throws exceptions in certain conditions, verify those cases explicitly with assertThrows.
• Avoid Testing Private Methods Directly: Focus on public APIs. If a private method is hard to test through public behavior, consider extracting it into a separate class with its tests.
• Keep Tests Fast and Deterministic: Unit tests should run in milliseconds and produce the same result every time. Avoid relying on timeouts, threads, or external systems.
• Always Prepare and Clean Up the State: Use @BeforeEach to create new objects for every test and @AfterEach to clean up if needed. Avoid shared mutable state between tests.
• Avoid Tight Coupling: Ensure that your tests are loosely coupled during implementation. This makes it easier to refactor code and update tests independently.

Looking to speed up and simplify your test creation process? Explore how AI unit test generation can automate and enhance your Java testing workflow.

Conclusion

By now, you’ve seen how JUnit can streamline your testing workflow by writing clear, maintainable unit tests. We have also seen how you can scale JUnit tests with tools like Selenium and perform Java unit testing in the cloud. This approach not only saves time and reduces bugs but also helps you ship with confidence, knowing your code is tested and reliable.