org.assertj.core.api

Interface EnumerableAssert<SELF extends EnumerableAssert<SELF,ELEMENT>,ELEMENT>

Type Parameters:

SELF - the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.

ELEMENT - the type of elements of the "actual" value.

All Known Subinterfaces:

IndexedObjectEnumerableAssert<SELF,ELEMENT>, ObjectEnumerableAssert<SELF,ELEMENT>

All Known Implementing Classes:

AbstractArrayAssert, AbstractBooleanArrayAssert, AbstractByteArrayAssert, AbstractCharArrayAssert, AbstractCharSequenceAssert, AbstractDoubleArrayAssert, AbstractEnumerableAssert, AbstractFloatArrayAssert, AbstractIntArrayAssert, AbstractIterableAssert, AbstractListAssert, AbstractLongArrayAssert, AbstractMapAssert, AbstractObjectArrayAssert, AbstractShortArrayAssert, AbstractStringAssert, AtomicIntegerArrayAssert, AtomicLongArrayAssert, AtomicReferenceArrayAssert, BooleanArrayAssert, ByteArrayAssert, CharArrayAssert, CharSequenceAssert, ClassBasedNavigableIterableAssert, ClassBasedNavigableListAssert, DoubleArrayAssert, FactoryBasedNavigableIterableAssert, FactoryBasedNavigableListAssert, FloatArrayAssert, IntArrayAssert, IterableAssert, ListAssert, LongArrayAssert, MapAssert, ObjectArrayAssert, ProxyableIterableAssert, ProxyableListAssert, ProxyableMapAssert, ProxyableObjectArrayAssert, ShortArrayAssert, StringAssert

public interface EnumerableAssert<SELF extends EnumerableAssert<SELF,ELEMENT>,ELEMENT>

Assertions applicable to groups of values that can be enumerated (e.g. arrays, collections or strings.)

Author:

Yvonne Wang, Alex Ruiz, Mikhail Mazursky, Nicolas François

Method Summary

Modifier and Type	Method and Description
SELF	hasSameSizeAs(Iterable<?> other) Verifies that the actual group has the same size as given Iterable.
SELF	hasSameSizeAs(Object array) Verifies that the actual group has the same size as given array.
SELF	hasSize(int expected) Verifies that the number of values in the actual group is equal to the given one.
SELF	hasSizeBetween(int lowerBoundary, int higherBoundary) Verifies that the number of values in the actual group is between the given boundaries (inclusive).
SELF	hasSizeGreaterThan(int boundary) Verifies that the number of values in the actual group is greater than the given boundary.
SELF	hasSizeGreaterThanOrEqualTo(int boundary) Verifies that the number of values in the actual group is greater than or equal to the given boundary.
SELF	hasSizeLessThan(int boundary) Verifies that the number of values in the actual group is less than the given boundary.
SELF	hasSizeLessThanOrEqualTo(int boundary) Verifies that the number of values in the actual group is less than or equal to the given boundary.
void	isEmpty() Verifies that the actual group of values is empty.
SELF	isNotEmpty() Verifies that the actual group of values is not empty.
void	isNullOrEmpty() Verifies that the actual group of values is null or empty.
SELF	usingDefaultElementComparator() Revert to standard comparison for incoming assertion group element checks.
SELF	usingElementComparator(Comparator<? super ELEMENT> customComparator) Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.

Method Detail

isNullOrEmpty

void isNullOrEmpty()

Verifies that the actual group of values is null or empty.

Example:

 // assertions will pass
 List<String> strings = new ArrayList<>();
 assertThat(strings).isNullOrEmpty();
 assertThat(new int[] { }).isNullOrEmpty();

 // assertions will fail
 assertThat(new String[] { "a", "b"}).isNullOrEmpty();
 assertThat(Arrays.asList(1, 2, 3)).isNullOrEmpty();

Throws:

AssertionError - if the actual group of values is not null or not empty.

isEmpty

void isEmpty()

Verifies that the actual group of values is empty.

Example:

 // assertions will pass
 assertThat(new ArrayList()).isEmpty();
 assertThat(new int[] { }).isEmpty();

 // assertions will fail
 assertThat(new String[] { "a", "b" }).isEmpty();
 assertThat(Arrays.asList(1, 2, 3)).isEmpty();

Throws:

AssertionError - if the actual group of values is not empty.

isNotEmpty

SELF isNotEmpty()

Verifies that the actual group of values is not empty.

Example:

 // assertions will pass
 assertThat(new String[] { "a", "b" }).isNotEmpty();
 assertThat(Arrays.asList(1, 2, 3)).isNotEmpty();

 // assertions will fail
 assertThat(new ArrayList()).isNotEmpty();
 assertThat(new int[] { }).isNotEmpty();

Returns:

this assertion object.

Throws:

AssertionError - if the actual group of values is empty.

hasSize

SELF hasSize(int expected)

Verifies that the number of values in the actual group is equal to the given one.

Example:

 // assertions will pass
 assertThat(new String[] { "a", "b" }).hasSize(2);
 assertThat(Arrays.asList(1, 2, 3)).hasSize(3);

 // assertions will fail
 assertThat(new ArrayList()).hasSize(1);
 assertThat(new int[] { 1, 2, 3 }).hasSize(2);

Parameters:

expected - the expected number of values in the actual group.

Returns:

this assertion object.

Throws:

AssertionError - if the number of values of the actual group is not equal to the given one.

hasSizeGreaterThan

SELF hasSizeGreaterThan(int boundary)

Verifies that the number of values in the actual group is greater than the given boundary.

Example:

 // assertions will pass
 assertThat(new String[] { "a", "b" }).hasSizeGreaterThan(1);
 assertThat(Arrays.asList(1, 2, 3)).hasSizeGreaterThan(2);

 // assertions will fail
 assertThat(Arrays.asList(1, 2, 3)).hasSizeGreaterThan(3);
 assertThat(new int[] { 1, 2, 3 }).hasSizeGreaterThan(6);

Parameters:

boundary - the given value to compare the actual size to.

Returns:

this assertion object.

Throws:

AssertionError - if the number of values of the actual group is not greater than the boundary.

hasSizeGreaterThanOrEqualTo

SELF hasSizeGreaterThanOrEqualTo(int boundary)

Verifies that the number of values in the actual group is greater than or equal to the given boundary.

Example:

 // assertions will pass
 assertThat(Arrays.asList(1, 2, 3)).hasSizeGreaterThanOrEqualTo(3);
 assertThat(Arrays.asList(1, 2)).hasSizeGreaterThanOrEqualTo(1);

 // assertions will fail
 assertThat(Arrays.asList(1, 2)).hasSizeGreaterThanOrEqualTo(3);
 assertThat(new int[] { 1, 2, 3 }).hasSizeGreaterThanOrEqualTo(4);

Parameters:

boundary - the given value to compare the actual size to.

Returns:

this assertion object.

Throws:

AssertionError - if the number of values of the actual group is not greater than or equal to the boundary.

hasSizeLessThan

SELF hasSizeLessThan(int boundary)

Verifies that the number of values in the actual group is less than the given boundary.

Example:

 // assertions will pass
 assertThat(new String[] { "a", "b" }).hasSizeLessThan(5);
 assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThan(4);

 // assertions will fail
 assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThan(3);
 assertThat(new int[] { 1, 2, 3 }).hasSizeLessThan(2);

Parameters:

boundary - the given value to compare the actual size to.

Returns:

this assertion object.

Throws:

AssertionError - if the number of values of the actual group is not less than the boundary.

hasSizeLessThanOrEqualTo

SELF hasSizeLessThanOrEqualTo(int boundary)

Verifies that the number of values in the actual group is less than or equal to the given boundary.

Example:

 // assertions will pass
 assertThat(new String[] { "a", "b" }).hasSizeLessThanOrEqualTo(3);
 assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThanOrEqualTo(5)
                                   .hasSizeLessThanOrEqualTo(3);

 // assertions will fail
 assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThanOrEqualTo(2);
 assertThat(new int[] { 1, 2, 3 }).hasSizeLessThanOrEqualTo(1);

Parameters:

boundary - the given value to compare the actual size to.

Returns:

this assertion object.

Throws:

AssertionError - if the number of values of the actual group is not less than or equal to the boundary.

hasSizeBetween

SELF hasSizeBetween(int lowerBoundary,
                    int higherBoundary)

Verifies that the number of values in the actual group is between the given boundaries (inclusive).

Example:

 // assertions will pass
 assertThat(new String[] { "a", "b" }).hasSizeBetween(0, 4);
 assertThat(Arrays.asList(1, 2, 3)).hasSizeBetween(2, 3)
                                   .hasSizeBetween(3, 4)
                                   .hasSizeBetween(3, 3);

 // assertions will fail
 assertThat(new ArrayList()).hasSizeBetween(1, 3);
 assertThat(new int[] { 1, 2, 3 }).hasSizeBetween(4, 6);
 assertThat(new int[] { 1, 2, 3, 4 }).hasSizeBetween(0, 2);

Parameters:

lowerBoundary - the lower boundary compared to which actual size should be greater than or equal to.

higherBoundary - the higher boundary compared to which actual size should be less than or equal to.

Returns:

this assertion object.

Throws:

AssertionError - if the number of values of the actual group is not between the boundaries.

hasSameSizeAs

SELF hasSameSizeAs(Iterable<?> other)

Verifies that the actual group has the same size as given Iterable.

Example:

 Iterable<String> abc = newArrayList("a", "b", "c");
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);

 // assertion will pass
 assertThat(elvesRings).hasSameSizeAs(abc);

 // assertions will fail
 assertThat(elvesRings).hasSameSizeAs(Arrays.asList(1, 2));
 assertThat(elvesRings).hasSameSizeAs(Arrays.asList(1, 2, 3, 4));

Parameters:

other - the Iterable to compare size with actual group.

Returns:

this assertion object.

Throws:

AssertionError - if the actual group is null.

AssertionError - if the other Iterable is null.

AssertionError - if actual group and given Iterable don't have the same size.

hasSameSizeAs

SELF hasSameSizeAs(Object array)

Verifies that the actual group has the same size as given array.

Parameter is declared as Object to accept both Object[] and primitive arrays (e.g. int[]).

Example:

 int[] oneTwoThree = {1, 2, 3};
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);

 // assertion will pass
 assertThat(elvesRings).hasSameSizeAs(oneTwoThree);

 // assertions will fail
 assertThat(elvesRings).hasSameSizeAs(new int[] { 1, 2});
 assertThat(elvesRings).hasSameSizeAs(new int[] { 1, 2, 3, 4});

Parameters:

array - the array to compare size with actual group.

Returns:

this assertion object.

Throws:

AssertionError - if the actual group is null.

AssertionError - if the array parameter is null or is not a true array.

AssertionError - if actual group and given array don't have the same size.

usingElementComparator

SELF usingElementComparator(Comparator<? super ELEMENT> customComparator)

Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.

Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default comparison strategy.

Examples :

 // compares invoices by payee
 assertThat(invoiceList).usingComparator(invoicePayeeComparator).isEqualTo(expectedInvoiceList);

 // compares invoices by date, doesNotHaveDuplicates and contains both use the given invoice date comparator
 assertThat(invoiceList).usingComparator(invoiceDateComparator).doesNotHaveDuplicates().contains(may2010Invoice);

 // as assertThat(invoiceList) creates a new assertion, it falls back to standard comparison strategy
 // based on Invoice's equal method to compare invoiceList elements to lowestInvoice.
 assertThat(invoiceList).contains(lowestInvoice);

 // standard comparison : the fellowshipOfTheRing includes Gandalf but not Sauron (believe me) ...
 assertThat(fellowshipOfTheRing).contains(gandalf)
                                .doesNotContain(sauron);

 // ... but if we compare only races, Sauron is in fellowshipOfTheRing because he's a Maia like Gandalf.
 assertThat(fellowshipOfTheRing).usingElementComparator(raceComparator)
                                .contains(sauron);

Parameters:

customComparator - the comparator to use for incoming assertion checks.

Returns:

this assertion object.

Throws:

NullPointerException - if the given comparator is null.

usingDefaultElementComparator

SELF usingDefaultElementComparator()

Revert to standard comparison for incoming assertion group element checks.

This method should be used to disable a custom comparison strategy set by calling usingElementComparator(Comparator).

Returns:

this assertion object.