Skip to main content

Type-specific assertions

AssertJ provides rich, expressive assertions tailored to specific types. These specialized assertions make your tests more readable and provide better failure messages compared to generic boolean checks.

Collection assertions​

AssertJ offers numerous assertions specifically designed for collections, going far beyond simple size checks.

CollectionAssertions.java
import org.junit.jupiter.api.Test;

import java.util.List;

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

class CollectionAssertions {

    List<String> languages = List.of("Java", "Python", "JavaScript", "Kotlin");

    @Test
    void collection() {
        assertFalse(languages.isEmpty());
        assertEquals(4, languages.size());
        assertTrue(languages.contains("Java"));
        assertTrue(languages.containsAll(List.of("Java", "Kotlin")));
        assertFalse(languages.contains("Ruby"));
    }
}
warning

Multiple separate assertions are verbose and don't provide context about the collection being tested.

Advanced collection assertions​

AdvancedCollectionAssertions.java
import org.junit.jupiter.api.Test;

import java.util.List;

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

class AdvancedCollectionAssertions {

    List<Integer> numbers = List.of(2, 4, 6, 8, 10);

    @Test
    void allMatch() {
        boolean allEven = numbers.stream().allMatch(n -> n % 2 == 0);
        assertTrue(allEven);

        boolean anyGreaterThan5 = numbers.stream().anyMatch(n -> n > 5);
        assertTrue(anyGreaterThan5);

        boolean noneNegative = numbers.stream().noneMatch(n -> n < 0);
        assertTrue(noneNegative);
    }
}

Date and time assertions​

Testing temporal values requires careful handling of precision and timezones. AssertJ provides specialized assertions that make date comparisons intuitive.

DateAssertions.java
import org.junit.jupiter.api.Test;

import java.time.LocalDate;
import java.time.LocalDateTime;

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

class DateAssertions {

    LocalDateTime now = LocalDateTime.now();
    LocalDate today = LocalDate.now();

    @Test
    void dates() {
        assertTrue(now.isAfter(LocalDateTime.now().minusDays(1)));
        assertTrue(now.isBefore(LocalDateTime.now().plusDays(1)));
        assertEquals(2025, today.getYear());
        assertTrue(today.getMonthValue() >= 1 && today.getMonthValue() <= 12);
    }
}
warning

Manual date comparisons are verbose and error-prone, especially when checking ranges or specific components.

Date tolerance assertions​

DateToleranceAssertions.java
import org.junit.jupiter.api.Test;

import java.time.Duration;
import java.time.LocalDateTime;

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

class DateToleranceAssertions {

    @Test
    void timestampWithinTolerance() {
        LocalDateTime expected = LocalDateTime.of(2025, 10, 7, 12, 0, 0);
        LocalDateTime actual = LocalDateTime.of(2025, 10, 7, 12, 0, 3);

        Duration diff = Duration.between(expected, actual);
        assertTrue(Math.abs(diff.getSeconds()) <= 5);
    }
}

File and path assertions​

Testing file system operations benefits greatly from AssertJ's specialized assertions for files and paths.

FileAssertions.java
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

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

class FileAssertions {

    Path configFile = Path.of("config.properties");

    @Test
    void file() throws IOException {
        assertTrue(Files.exists(configFile));
        assertTrue(Files.isRegularFile(configFile));
        assertFalse(Files.isDirectory(configFile));
        assertTrue(Files.isReadable(configFile));
        assertFalse(Files.size(configFile) == 0);
        assertEquals(".properties", getExtension(configFile.toString()));
    }

    String getExtension(String filename) {
        return filename.substring(filename.lastIndexOf('.'));
    }
}
warning

File checks require verbose Files utility calls and manual extension parsing.

File content assertions​

FileContentAssertions.java
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

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

class FileContentAssertions {

    Path logFile = Path.of("app.log");

    @Test
    void fileContent() throws IOException {
        String content = Files.readString(logFile);
        assertTrue(content.contains("ERROR"));

        List<String> lines = Files.readAllLines(logFile);
        assertTrue(lines.stream().anyMatch(line -> line.contains("ERROR")));
    }
}

Map assertions​

Maps have their own set of specialized assertions for keys, values, and entries.

MapAssertions.java
import org.junit.jupiter.api.Test;

import java.util.Map;

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

class MapAssertions {

    Map<String, Integer> scores = Map.of(
            "Alice", 95,
            "Bob", 87,
            "Charlie", 92
    );

    @Test
    void map() {
        assertFalse(scores.isEmpty());
        assertEquals(3, scores.size());
        assertTrue(scores.containsKey("Alice"));
        assertEquals(95, scores.get("Alice"));
        assertTrue(scores.containsValue(87));
    }
}

String assertions​

String assertions go beyond simple equality checks to offer pattern matching, case handling, and content validation.

StringAssertions.java
import org.junit.jupiter.api.Test;

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

class StringAssertions {

    String email = "user@example.com";

    @Test
    void string() {
        assertFalse(email.isEmpty());
        assertTrue(email.contains("@"));
        assertTrue(email.startsWith("user"));
        assertTrue(email.endsWith(".com"));
        assertTrue(email.matches(".*@.*\\..*"));
    }
}