CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-assertj--assertj-core

Fluent assertion library providing rich assertions for Java tests with expressive failure messages

—

Pending
Overview
Eval results
Files

collections.mddocs/

Collections

Comprehensive assertions for arrays, lists, maps, iterables, and other collection types with size, content, ordering, and membership verification.

Core Imports

import static org.assertj.core.api.Assertions.*;

Capabilities

Array Assertions

Assertions for object and primitive arrays.

// Object arrays
ObjectArrayAssert<T> assertThat(T[] actual)

// Primitive arrays
BooleanArrayAssert assertThat(boolean[] actual)
ByteArrayAssert assertThat(byte[] actual)
CharArrayAssert assertThat(char[] actual)
DoubleArrayAssert assertThat(double[] actual)
FloatArrayAssert assertThat(float[] actual)
IntArrayAssert assertThat(int[] actual)
LongArrayAssert assertThat(long[] actual)
ShortArrayAssert assertThat(short[] actual)

// Array methods
ObjectArrayAssert<T> hasSize(int expected)
ObjectArrayAssert<T> isEmpty()
ObjectArrayAssert<T> isNotEmpty()
ObjectArrayAssert<T> contains(T... values)
ObjectArrayAssert<T> containsOnly(T... values)
ObjectArrayAssert<T> containsExactly(T... values)
ObjectArrayAssert<T> containsExactlyInAnyOrder(T... values)
ObjectArrayAssert<T> containsSequence(T... sequence)
ObjectArrayAssert<T> containsSubsequence(T... subsequence)
ObjectArrayAssert<T> doesNotContain(T... values)
ObjectArrayAssert<T> startsWith(T... sequence)
ObjectArrayAssert<T> endsWith(T... sequence)
ObjectArrayAssert<T> isSorted()
ObjectArrayAssert<T> isSortedAccordingTo(Comparator<? super T> comparator)

Usage examples:

String[] names = {"Alice", "Bob", "Charlie"};
assertThat(names)
    .hasSize(3)
    .contains("Bob")
    .containsExactly("Alice", "Bob", "Charlie")
    .startsWith("Alice")
    .endsWith("Charlie");

int[] numbers = {1, 2, 3, 4, 5};
assertThat(numbers)
    .hasSize(5)
    .contains(3)
    .isSorted()
    .containsSequence(2, 3, 4);

List Assertions

Specialized assertions for List collections.

ListAssert<T> assertThat(List<T> actual)

// List-specific methods (in addition to Iterable methods)
ListAssert<T> isSorted()
ListAssert<T> isSortedAccordingTo(Comparator<? super T> comparator)
ObjectAssert<T> element(int index)
ListAssert<T> hasOnlyOneElementSatisfying(Consumer<T> elementAssertions)

Usage examples:

List<String> fruits = Arrays.asList("apple", "banana", "cherry");
assertThat(fruits)
    .hasSize(3)
    .containsExactly("apple", "banana", "cherry")
    .element(1).isEqualTo("banana");

List<Integer> sortedNumbers = Arrays.asList(1, 2, 3, 4, 5);
assertThat(sortedNumbers).isSorted();

Iterable Assertions

Generic assertions for any Iterable collection.

IterableAssert<T> assertThat(Iterable<T> actual)

// Iterable methods
IterableAssert<T> hasSize(int expected)
IterableAssert<T> hasSizeGreaterThan(int expected)
IterableAssert<T> hasSizeLessThan(int expected)
IterableAssert<T> hasSizeBetween(int lowerBoundary, int higherBoundary)
IterableAssert<T> isEmpty()
IterableAssert<T> isNotEmpty()
IterableAssert<T> contains(T... values)
IterableAssert<T> containsOnly(T... values)
IterableAssert<T> containsOnlyOnce(T... values)
IterableAssert<T> containsExactly(T... values)
IterableAssert<T> containsExactlyInAnyOrder(T... values)
IterableAssert<T> containsSequence(T... sequence)
IterableAssert<T> containsSubsequence(T... subsequence)
IterableAssert<T> doesNotContain(T... values)
IterableAssert<T> doesNotContainAnyElementsOf(Iterable<T> iterable)
IterableAssert<T> containsAll(Iterable<T> iterable)
IterableAssert<T> allMatch(Predicate<? super T> predicate)
IterableAssert<T> anyMatch(Predicate<? super T> predicate)
IterableAssert<T> noneMatch(Predicate<? super T> predicate)
IterableAssert<T> hasOnlyOneElementSatisfying(Consumer<T> elementAssertions)

Usage examples:

Set<String> colors = Set.of("red", "green", "blue");
assertThat(colors)
    .hasSize(3)
    .contains("red", "blue")
    .doesNotContain("yellow")
    .allMatch(color -> color.length() >= 3);

Collection<User> users = getActiveUsers();
assertThat(users)
    .isNotEmpty()
    .allMatch(User::isActive)
    .anyMatch(user -> user.getRole() == Role.ADMIN);

Map Assertions

Comprehensive assertions for Map collections.

MapAssert<K, V> assertThat(Map<K, V> actual)

// Map methods
MapAssert<K, V> hasSize(int expected)
MapAssert<K, V> isEmpty()
MapAssert<K, V> isNotEmpty()
MapAssert<K, V> containsKey(K key)
MapAssert<K, V> containsKeys(K... keys)
MapAssert<K, V> doesNotContainKey(K key)
MapAssert<K, V> doesNotContainKeys(K... keys)
MapAssert<K, V> containsValue(V value)
MapAssert<K, V> containsValues(V... values)
MapAssert<K, V> doesNotContainValue(V value)
MapAssert<K, V> containsEntry(K key, V value)
MapAssert<K, V> containsEntry(MapEntry entry)
MapAssert<K, V> containsExactlyEntriesOf(Map<K, V> other)
MapAssert<K, V> containsExactlyInAnyOrderEntriesOf(Map<K, V> other)
MapAssert<K, V> doesNotContainEntry(K key, V value)
MapAssert<K, V> containsOnlyKeys(K... keys)
MapAssert<K, V> containsOnlyKeys(Iterable<K> keys)
MapAssert<K, V> hasEntrySatisfying(K key, Consumer<V> valueRequirements)

Usage examples:

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

assertThat(scores)
    .hasSize(3)
    .containsKeys("Alice", "Bob", "Charlie")
    .containsEntry("Alice", 95)
    .containsValue(87)
    .doesNotContainKey("David");

assertThat(scores)
    .hasEntrySatisfying("Alice", score -> assertThat(score).isGreaterThan(90));

2D Array Assertions

Assertions for two-dimensional arrays.

// 2D Object arrays
Object2DArrayAssert<T> assertThat(T[][] actual)

// 2D Primitive arrays
Boolean2DArrayAssert assertThat(boolean[][] actual)
Byte2DArrayAssert assertThat(byte[][] actual)
Char2DArrayAssert assertThat(char[][] actual)
Double2DArrayAssert assertThat(double[][] actual)
Float2DArrayAssert assertThat(float[][] actual)
Int2DArrayAssert assertThat(int[][] actual)
Long2DArrayAssert assertThat(long[][] actual)
Short2DArrayAssert assertThat(short[][] actual)

// 2D Array methods
Object2DArrayAssert<T> hasSize(int expected)
Object2DArrayAssert<T> hasDimensions(int expectedFirstDimension, int expectedSecondDimension)
Object2DArrayAssert<T> isEmpty()
Object2DArrayAssert<T> isNotEmpty()
Object2DArrayAssert<T> isDeepEqualTo(T[][] expected)
Object2DArrayAssert<T> isNotDeepEqualTo(T[][] expected)

Usage examples:

String[][] matrix = {
    {"a", "b", "c"},
    {"d", "e", "f"}
};

assertThat(matrix)
    .hasSize(2)
    .hasDimensions(2, 3);

int[][] numbers = {{1, 2}, {3, 4}};
assertThat(numbers).hasDimensions(2, 2);

Iterator and Spliterator Assertions

Assertions for iterators and spliterators.

IteratorAssert<T> assertThat(Iterator<T> actual)
SpliteratorAssert<T> assertThat(Spliterator<T> actual)

// Iterator methods
IteratorAssert<T> hasNext()
IteratorAssert<T> isExhausted()
IteratorAssert<T> toIterable()

// Spliterator methods
SpliteratorAssert<T> hasCharacteristics(int... characteristics)
SpliteratorAssert<T> hasOnlyCharacteristics(int... characteristics)

Filtering and Extraction

Extract values from collections for focused assertions.

// Filtering arrays and collections
Filters<E> filter(E[] array)
Filters<E> filter(Iterable<E> iterable)

// Property extraction from objects
ObjectArrayAssert<Object> extracting(String propertyName)
ObjectArrayAssert<Tuple> extracting(String... propertyNames)
ObjectArrayAssert<Object> extracting(Function<T, Object> extractor)
ObjectArrayAssert<Tuple> extracting(Function<T, Object>... extractors)

// Flattening nested collections
ListAssert<Object> flatExtracting(String propertyName)
ListAssert<Object> flatExtracting(Function<T, ?> extractor)

Usage examples:

List<Person> people = Arrays.asList(
    new Person("Alice", 30),
    new Person("Bob", 25),
    new Person("Charlie", 35)
);

// Extract property values
assertThat(people)
    .extracting(Person::getName)
    .containsExactly("Alice", "Bob", "Charlie");

// Extract multiple properties
assertThat(people)
    .extracting("name", "age")
    .contains(tuple("Alice", 30), tuple("Bob", 25));

// Filter then assert
assertThat(people)
    .filteredOn(person -> person.getAge() > 28)
    .extracting(Person::getName)
    .containsOnly("Alice", "Charlie");

// Using string-based filtering
assertThat(people)
    .filteredOn("age", 30)
    .hasSize(1)
    .extracting("name")
    .containsExactly("Alice");

Advanced Collection Operations

// Grouping elements
Map<K, List<T>> groupBy(Function<T, K> classifier)

// Element access with index
ObjectAssert<T> element(int index)
ObjectAssert<T> first()
ObjectAssert<T> last()

// Satisfying conditions
IterableAssert<T> allSatisfy(Consumer<T> requirements)
IterableAssert<T> anySatisfy(Consumer<T> requirements) 
IterableAssert<T> noneSatisfy(Consumer<T> requirements)
IterableAssert<T> hasOnlyOneElementSatisfying(Consumer<T> requirements)

Usage examples:

List<String> words = Arrays.asList("hello", "world", "test");

assertThat(words)
    .first().isEqualTo("hello");
    
assertThat(words)
    .last().isEqualTo("test");
    
assertThat(words)
    .allSatisfy(word -> assertThat(word).isNotBlank())
    .anySatisfy(word -> assertThat(word).startsWith("h"));

Types

// Index for element access
class Index {
    static Index atIndex(int index)
}

// Map entry for map assertions
class MapEntry<K, V> {
    static <K, V> MapEntry<K, V> entry(K key, V value)
}

// Tuple for multi-value extraction
class Tuple {
    static Tuple tuple(Object... values)
    Object[] toArray()
}

// Filter operators
class InFilter<E> implements FilterOperator<E> {
    static <E> InFilter<E> in(E... elements)
    static <E> InFilter<E> in(Iterable<E> elements)
}

class NotInFilter<E> implements FilterOperator<E> {
    static <E> NotInFilter<E> notIn(E... elements)
    static <E> NotInFilter<E> notIn(Iterable<E> elements)
}

// Predicates for matching
interface Predicate<T> {
    boolean test(T t);
}

// Functions for extraction
interface Function<T, R> {
    R apply(T t);
}

// Comparators for sorting
interface Comparator<T> {
    int compare(T o1, T o2);
}

// Consumer for element validation
interface Consumer<T> {
    void accept(T t);
}

Install with Tessl CLI

npx tessl i tessl/maven-org-assertj--assertj-core

docs

advanced.md

basic-assertions.md

collections.md

conditions.md

dates-times.md

exceptions.md

index.md

soft-assertions.md

strings.md

tile.json