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:

Assertion	Purpose
assertEquals(expected, actual)	Checks that two values are equal
assertNotEquals(unexpected, actual)	Checks that two values are not equal
assertTrue(condition)	Checks that a condition is true
assertFalse(condition)	Checks that a condition is false
assertNull(value)	Checks that a value is null
assertNotNull(value)	Checks that a value is not null
assertSame(expected, actual)	Checks that two references point to the same object
assertNotSame(unexpected, actual)	Checks that two references do not point to the same object
assertArrayEquals(expected, actual)	Checks that two arrays are equal
assertThrows(type, executable)	Checks that an exception is thrown
assertAll(executables)	Groups multiple assertions
fail(message)	Fails the test explicitly

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