In JUnit, assertions are used to verify that your code produces the expected result. If an assertion fails, the test fails.

JUnit 5 assertions are provided by the org.junit.jupiter.api.Assertions class.

Basic Example

import org.junit.jupiter.api.Test;

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

class CalculatorTest {

    @Test
    void testAddition() {
        int result = 2 + 3;

        assertEquals(5, result);
    }
}

In this example, the test passes because 2 + 3 equals 5.

Common JUnit Assertions

assertEquals()

Use assertEquals() to check whether two values are equal.

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

assertEquals(10, 5 + 5);
assertEquals("Hello", "He" + "llo");

You can also provide a failure message:

assertEquals(10, 5 + 4, "The result should be 10");

assertNotEquals()

Use assertNotEquals() to check that two values are not equal.

import static org.junit.jupiter.api.Assertions.assertNotEquals;

assertNotEquals(10, 5 + 4);

assertTrue() and assertFalse()

Use assertTrue() when a condition should be true.

import static org.junit.jupiter.api.Assertions.assertTrue;

assertTrue(10 > 5);

Use assertFalse() when a condition should be false.

import static org.junit.jupiter.api.Assertions.assertFalse;

assertFalse(10 < 5);

assertNull() and assertNotNull()

Use assertNull() to check that a value is null.

import static org.junit.jupiter.api.Assertions.assertNull;

String name = null;

assertNull(name);

Use assertNotNull() to check that a value is not null.

import static org.junit.jupiter.api.Assertions.assertNotNull;

String name = "Kode Java";

assertNotNull(name);

assertSame() and assertNotSame()

Use assertSame() to check whether two references point to the same object.

import static org.junit.jupiter.api.Assertions.assertSame;

String text = "Java";
String sameText = text;

assertSame(text, sameText);

Use assertNotSame() when two references should not point to the same object.

import static org.junit.jupiter.api.Assertions.assertNotSame;

String first = new String("Java");
String second = new String("Java");

assertNotSame(first, second);

Note that assertEquals() checks object equality, while assertSame() checks object identity.

assertArrayEquals()

Use assertArrayEquals() to compare arrays.

import static org.junit.jupiter.api.Assertions.assertArrayEquals;

int[] expected = {1, 2, 3};
int[] actual = {1, 2, 3};

assertArrayEquals(expected, actual);

assertThrows()

Use assertThrows() to verify that a block of code throws an expected exception.

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertThrows;

class NumberParserTest {

    @Test
    void testInvalidNumber() {
        assertThrows(NumberFormatException.class, () -> {
            Integer.parseInt("abc");
        });
    }
}

You can also inspect the thrown exception:

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

NumberFormatException exception = assertThrows(
        NumberFormatException.class,
        () -> Integer.parseInt("abc")
);

assertEquals("For input string: \"abc\"", exception.getMessage());

assertAll()

Use assertAll() to group multiple assertions together. JUnit will run all assertions and report all failures.

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

class UserTest {

    @Test
    void testUserDetails() {
        String name = "Alice";
        int age = 25;

        assertAll(
                () -> assertEquals("Alice", name),
                () -> assertEquals(25, age),
                () -> assertTrue(age >= 18)
        );
    }
}

Without assertAll(), the test stops at the first failed assertion.

fail()

Use fail() when a test should fail explicitly.

import static org.junit.jupiter.api.Assertions.fail;

fail("This test should not reach this point");

This is often useful inside conditional logic or exception handling.

Complete Example

import org.junit.jupiter.api.Test;

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

class StringUtilsTest {

    @Test
    void testStringAssertions() {
        String text = "JUnit";

        assertEquals("JUnit", text);
        assertNotEquals("TestNG", text);
        assertTrue(text.startsWith("J"));
        assertFalse(text.isEmpty());
        assertNotNull(text);
    }

    @Test
    void testArrayAssertions() {
        int[] numbers = {1, 2, 3};

        assertArrayEquals(new int[]{1, 2, 3}, numbers);
    }

    @Test
    void testExceptionAssertion() {
        assertThrows(NumberFormatException.class, () -> {
            Integer.parseInt("not-a-number");
        });
    }
}

Using Static Imports

Most JUnit tests use static imports so assertions can be written directly:

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

Then you can write:

assertEquals(5, result);
assertTrue(result > 0);
assertThrows(Exception.class, () -> someMethod());

Instead of:

Assertions.assertEquals(5, result);
Assertions.assertTrue(result > 0);
Assertions.assertThrows(Exception.class, () -> someMethod());

Summary

Common JUnit assertion methods include:

In short, assertions are the main way to express what your code is expected to do in a JUnit test.