JUnit Assumptions

Introduction

In this chapter, we will explore JUnit assumptions. Assumptions are conditions that must be met for a test to proceed. If an assumption fails, the test is aborted and marked as skipped. This is useful for tests that should only run under specific conditions, such as certain environments or configurations.

What are Assumptions?

Assumptions allow you to define preconditions for your tests. If an assumption is not met, JUnit will skip the test rather than fail it. This helps in scenarios where certain tests are only relevant under specific circumstances, and you don’t want these tests to fail when those conditions are not met.

Overview of Assumptions in JUnit

JUnit provides several static methods in the Assumptions class to define assumptions:

• assumeTrue(boolean): The test will proceed if the condition is true; otherwise, it will be skipped.
• assumeFalse(boolean): The test will proceed if the condition is false; otherwise, it will be skipped.
• assumeThat(T actual, Matcher<T> matcher): The test will proceed if the actual value matches the matcher; otherwise, it will be skipped.

Example: Using Assumptions

Let’s create examples to demonstrate how to use assumptions in JUnit tests.

Step 1: Create Class Under Test

Calculator Class

The Calculator class will have basic arithmetic operations.

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public int divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("Division by zero");
        }
        return a / b;
    }
}

Step 2: Create Test Class with Assumptions

CalculatorTest

The CalculatorTest class will contain tests for the Calculator class using assumptions to define preconditions.

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.EnabledOnOs;
import org.junit.jupiter.api.condition.OS;
import static org.junit.jupiter.api.Assumptions.*;
import static org.junit.jupiter.api.Assertions.*;

public class CalculatorTest {

    private Calculator calculator = new Calculator();

    @Test
    void testAdd() {
        assertEquals(5, calculator.add(2, 3), "2 + 3 should equal 5");
    }

    @Test
    void testSubtract() {
        assertEquals(2, calculator.subtract(5, 3), "5 - 3 should equal 2");
    }

    @Test
    void testMultiply() {
        assertEquals(6, calculator.multiply(2, 3), "2 * 3 should equal 6");
    }

    @Test
    void testDivide() {
        assertEquals(2, calculator.divide(6, 3), "6 / 3 should equal 2");
    }

    @Test
    void testDivideByZero() {
        Exception exception = assertThrows(IllegalArgumentException.class, () -> {
            calculator.divide(1, 0);
        });
        assertEquals("Division by zero", exception.getMessage());
    }

    @Test
    void testOnlyOnCiServer() {
        assumeTrue("CI".equals(System.getenv("ENV")), "Test skipped because not running in CI environment");
        // test logic here
    }

    @Test
    void testOnlyOnDeveloperMachine() {
        assumeFalse("CI".equals(System.getenv("ENV")), "Test skipped because running in CI environment");
        // test logic here
    }

    @Test
    void testWithCustomAssumption() {
        String userHome = System.getProperty("user.home");
        assumeTrue(userHome != null && userHome.endsWith("user"), "Test skipped because user home is not correct");
        // test logic here
    }
}

Important Points

• assumeTrue: Use this method to specify a condition that must be true for the test to proceed. If the condition is false, the test is skipped.
• assumeFalse: Use this method to specify a condition that must be false for the test to proceed. If the condition is true, the test is skipped.
• Custom Assumptions: Assumptions can be based on environment variables, system properties, or any other conditions that are relevant to your tests.

Running the Tests

To run the tests, simply run the CalculatorTest class as a JUnit test. This will execute all test methods, but tests with failing assumptions will be skipped.

Using Eclipse

1. Run Tests: Right-click on the CalculatorTest file and select Run As > JUnit Test.
2. View Results: The results will be displayed in the JUnit view, showing which tests were skipped due to failed assumptions.

Using IntelliJ IDEA

1. Run Tests: Click the green run icon next to the CalculatorTest class and select Run.
2. View Results: The results will be displayed in the Run window, showing which tests were skipped due to failed assumptions.

Using VS Code

1. Run Tests: Open the CalculatorTest file and click the Run icon above the class declaration.
2. View Results: The results will be displayed in the Test Explorer, showing which tests were skipped due to failed assumptions.

Conclusion

JUnit assumptions provide a way to define preconditions for your tests. By using the Assumptions class, you can specify conditions that must be met for a test to proceed. If an assumption fails, the test is skipped rather than failed. This is useful for tests that are only relevant under specific conditions, such as certain environments or configurations. Using assumptions helps create more flexible and robust test suites that can adapt to different testing scenarios.