Interface ObjectEnumerableAssert<SELF extends ObjectEnumerableAssert<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 Superinterfaces:
EnumerableAssert<SELF,
ELEMENT>
- All Known Subinterfaces:
IndexedObjectEnumerableAssert<SELF,
ELEMENT>
- All Known Implementing Classes:
AbstractIterableAssert
,AbstractListAssert
,AbstractObjectArrayAssert
,AtomicReferenceArrayAssert
,ClassBasedNavigableIterableAssert
,ClassBasedNavigableListAssert
,FactoryBasedNavigableIterableAssert
,FactoryBasedNavigableListAssert
,IterableAssert
,ListAssert
,ObjectArrayAssert
,SoftAssertionIterableAssert
,SoftAssertionListAssert
-
Method Summary
Modifier and TypeMethodDescriptionVerifies that all the elements of actual match the givenPredicate
.Verifies that all the elements of actual match the givenPredicate
.allSatisfy
(Consumer<? super ELEMENT> requirements) Verifies that all the elements satisfy given requirements expressed as aConsumer
.anySatisfy
(Consumer<? super ELEMENT> requirements) Verifies that at least one element satisfies the given requirements expressed as aConsumer
.Verifies that each element value satisfies the given condition.areAtLeast
(int n, Condition<? super ELEMENT> condition) Verifies that there are at least n elements in the actual group satisfying the given condition.areAtLeastOne
(Condition<? super ELEMENT> condition) Verifies that there is at least one element in the actual group satisfying the given condition.Verifies that there are at most n elements in the actual group satisfying the given condition.areExactly
(int n, Condition<? super ELEMENT> condition) Verifies that there are exactly n elements in the actual group satisfying the given condition.Verifies that each element value does not satisfy the given condition.Verifies that the actual group contains the given values, in any order.containsAll
(Iterable<? extends ELEMENT> iterable) Verifies that the actual group contains all the elements of givenIterable
, in any order.containsExactly
(ELEMENT... values) Verifies that the actual group contains only the given values and nothing else, in order.
This assertion should only be used with groups that have a consistent iteration order (i.e.containsExactlyElementsOf
(Iterable<? extends ELEMENT> iterable) Same ascontainsExactly(Object...)
but handle theIterable
to array conversion : verifies that actual contains all the elements of the given iterable and nothing else in the same order.containsExactlyInAnyOrder
(ELEMENT... values) Verifies that the actual group contains exactly the given values and nothing else, in any order.Verifies that the actual group contains at least a null element.containsOnly
(ELEMENT... values) Verifies that the actual group contains only the given values and nothing else, in any order.containsOnlyElementsOf
(Iterable<? extends ELEMENT> iterable) Same semantic ascontainsOnly(Object[])
: verifies that actual contains all the elements of the given iterable and nothing else, in any order.containsOnlyOnce
(ELEMENT... values) Verifies that the actual group contains the given values only once.containsSequence
(ELEMENT... sequence) Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.containsSequence
(Iterable<? extends ELEMENT> sequence) Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.containsSubsequence
(ELEMENT... sequence) Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).containsSubsequence
(Iterable<? extends ELEMENT> sequence) Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).doesNotContain
(ELEMENT... values) Verifies that the actual group does not contain the given values.doesNotContainAnyElementsOf
(Iterable<? extends ELEMENT> iterable) Verifies that actual does not contain any elements of the givenIterable
(i.e.Verifies that the actual group does not contain null elements.doesNotContainSequence
(ELEMENT... sequence) Verifies that the actual group does not contain the given sequence, a sequence is defined by an ordered group of values without extra values between them.doesNotContainSequence
(Iterable<? extends ELEMENT> sequence) Verifies that the actual group does not contain the given sequence, a sequence is defined by an ordered group of values without extra values between them.doesNotContainSubsequence
(ELEMENT... sequence) Verifies that the actual group does not contain the given subsequence, a subsequence is defined by an ordered group of values with possibly extra values between them.doesNotContainSubsequence
(Iterable<? extends ELEMENT> sequence) Verifies that the actual group does not contain the given subsequence, a subsequence is defined by an ordered group of values with possibly extra values between them.Verifies that the actual group does not contain duplicates.Verifies that all elements do not satisfy the given condition.Verifies that the actual group ends with the given sequence of objects, without any other objects between them.hasAtLeastOneElementOfType
(Class<?> expectedType) Verifies that at least one element in the actualObject
group has the specified type (matching includes subclasses of the given type).hasOnlyElementsOfType
(Class<?> expectedType) Verifies that all the elements in the actualObject
group belong to the specified type (matching includes subclasses of the given type).hasOnlyElementsOfTypes
(Class<?>... types) Verifies that all elements of the actual group are instances of the given types.hasSameElementsAs
(Iterable<? extends ELEMENT> iterable) An alias ofcontainsOnlyElementsOf(Iterable)
: verifies that actual contains all the elements of the given iterable and nothing else, in any order.Verifies that all elements satisfy the given condition.haveAtLeast
(int n, Condition<? super ELEMENT> condition) Verifies that there are at least n elements in the actual group satisfying the given condition.haveAtLeastOne
(Condition<? super ELEMENT> condition) Verifies that there is at least one element in the actual group satisfying the given condition.haveAtMost
(int n, Condition<? super ELEMENT> condition) Verifies that there are at most n elements in the actual group satisfying the given condition.haveExactly
(int n, Condition<? super ELEMENT> condition) Verifies that there are exactly n elements in the actual group satisfying the given condition.isSubsetOf
(ELEMENT... values) Verifies that all the elements of actual are present in the given values.isSubsetOf
(Iterable<? extends ELEMENT> values) Verifies that all the elements of actual are present in the givenIterable
.startsWith
(ELEMENT... sequence) Verifies that the actual group starts with the given sequence of objects, without any other objects between them.Methods inherited from interface org.assertj.core.api.EnumerableAssert
hasSameSizeAs, hasSameSizeAs, hasSize, isEmpty, isNotEmpty, isNullOrEmpty, usingDefaultElementComparator, usingElementComparator
-
Method Details
-
contains
Verifies that the actual group contains the given values, in any order.Example :
Iterable<String> abc = newArrayList("a", "b", "c"); // assertions will pass assertThat(abc).contains("b", "a"); assertThat(abc).contains("b", "a", "b"); // assertion will fail assertThat(abc).contains("d");
- Parameters:
values
- the given values.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given argument isnull
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group isnull
.AssertionError
- if the actual group does not contain the given values.
-
containsOnly
Verifies that the actual group contains only the given values and nothing else, in any order.Example :
Iterable<String> abc = newArrayList("a", "b", "c"); // assertion will pass assertThat(abc).containsOnly("c", "b", "a"); // assertion will fail because "c" is missing assertThat(abc).containsOnly("a", "b");
- Parameters:
values
- the given values.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given argument isnull
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group isnull
.AssertionError
- if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones.
-
containsOnlyOnce
Verifies that the actual group contains the given values only once.Examples :
// lists are used in the examples but it would also work with arrays // assertions will pass assertThat(newArrayList("winter", "is", "coming")).containsOnlyOnce("winter"); assertThat(newArrayList("winter", "is", "coming")).containsOnlyOnce("coming", "winter"); // assertions will fail assertThat(newArrayList("winter", "is", "coming")).containsOnlyOnce("Lannister"); assertThat(newArrayList("Arya", "Stark", "daughter", "of", "Ned", "Stark")).containsOnlyOnce("Stark"); assertThat(newArrayList("Arya", "Stark", "daughter", "of", "Ned", "Stark")).containsOnlyOnce("Stark", "Lannister", "Arya");
- Parameters:
values
- the given values.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given argument isnull
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group isnull
.AssertionError
- if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more than once these values.
-
containsExactly
Verifies that the actual group contains only the given values and nothing else, in order.
This assertion should only be used with groups that have a consistent iteration order (i.e. don't use it withHashSet
, prefercontainsOnly(Object...)
in that case).Example :
// an Iterable is used in the example but it would also work with an array Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertion will pass assertThat(elvesRings).containsExactly(vilya, nenya, narya); // assertion will fail as actual and expected order differ assertThat(elvesRings).containsExactly(nenya, vilya, narya);
- Parameters:
values
- the given values.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given argument isnull
.AssertionError
- if the actual group isnull
.AssertionError
- if the actual group does not contain the given values with same order, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones or values are the same but the order is not.
-
containsExactlyInAnyOrder
Verifies that the actual group contains exactly the given values and nothing else, in any order.
Example :
// an Iterable is used in the example but it would also work with an array Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya, vilya); // assertion will pass assertThat(elvesRings).containsExactlyInAnyOrder(vilya, vilya, nenya, narya); // assertion will fail as vilya is contained twice in elvesRings. assertThat(elvesRings).containsExactlyInAnyOrder(nenya, vilya, narya);
- Parameters:
values
- the given values.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given argument isnull
.AssertionError
- if the actual group isnull
.AssertionError
- if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones.
-
containsSequence
Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.Use
containsSubsequence(Object...)
to allow values between the expected sequence values.Example:
// an Iterable is used in the example but it would also work with an array Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertions will pass assertThat(elvesRings).containsSequence(vilya, nenya) .containsSequence(nenya, narya); // assertions will fail, the elements order is correct but there is a value between them (nenya) assertThat(elvesRings).containsSequence(vilya, narya); assertThat(elvesRings).containsSequence(nenya, vilya);
- Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the given array isnull
.AssertionError
- if the actual group does not contain the given sequence.
-
containsSequence
Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.Use
containsSubsequence(Iterable)
to allow values between the expected sequence values.Example:
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertions will pass assertThat(elvesRings).containsSequence(newArrayList(vilya, nenya)) .containsSequence(newArrayList(nenya, narya)); // assertions will fail, the elements order is correct but there is a value between them (nenya) assertThat(elvesRings).containsSequence(newArrayList(vilya, narya)); assertThat(elvesRings).containsSequence(newArrayList(nenya, vilya));
- Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the given array isnull
.AssertionError
- if the actual group does not contain the given sequence.
-
doesNotContainSequence
Verifies that the actual group does not contain the given sequence, a sequence is defined by an ordered group of values without extra values between them.Use
doesNotContainSubsequence(Object...)
to also ensure the sequence does not exist with values between the expected sequence values.Example:
// an Iterable is used in the example but it would also work with an array Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertions will pass, the elements order is correct but there is a value between them (nenya) assertThat(elvesRings).doesNotContainSequence(vilya, narya) .doesNotContainSequence(nenya, vilya); // assertions will fail assertThat(elvesRings).doesNotContainSequence(vilya, nenya); assertThat(elvesRings).doesNotContainSequence(nenya, narya);
- Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the given array isnull
.AssertionError
- if the actual group contains the given sequence.
-
doesNotContainSequence
Verifies that the actual group does not contain the given sequence, a sequence is defined by an ordered group of values without extra values between them.Use
doesNotContainSubsequence(Iterable)
to also ensure the sequence does not exist with values between the sequence values.Example:
// an Iterable is used in the example but it would also work with an array Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertions will pass, the elements order is correct but there is a value between them (nenya) assertThat(elvesRings).doesNotContainSequence(newArrayList(vilya, narya)) .doesNotContainSequence(newArrayList(nenya, vilya)); // assertions will fail assertThat(elvesRings).doesNotContainSequence(newArrayList(vilya, nenya)); assertThat(elvesRings).doesNotContainSequence(newArrayList(nenya, narya));
- Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the given array isnull
.AssertionError
- if the actual group contains the given sequence.
-
containsSubsequence
Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).Example:
// an Iterable is used in the example but it would also work with an array Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertions will pass assertThat(elvesRings).containsSubsequence(vilya, nenya) .containsSubsequence(vilya, narya); // assertion will fail assertThat(elvesRings).containsSubsequence(nenya, vilya);
- Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the given array isnull
.AssertionError
- if the actual group does not contain the given subsequence.
-
containsSubsequence
Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).Example:
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertions will pass assertThat(elvesRings).containsSubsequence(newArrayList(vilya, nenya)) .containsSubsequence(newArrayList(vilya, narya)); // assertion will fail assertThat(elvesRings).containsSubsequence(newArrayList(nenya, vilya));
- Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the given array isnull
.AssertionError
- if the actual group does not contain the given subsequence.
-
doesNotContainSubsequence
Verifies that the actual group does not contain the given subsequence, a subsequence is defined by an ordered group of values with possibly extra values between them.Example:
// an Iterable is used in the example but it would also work with an array Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertions will pass assertThat(elvesRings).doesNotContainSubsequence(nenya, vilya) .doesNotContainSubsequence(narya, vilya); // assertion will fail assertThat(elvesRings).doesNotContainSubsequence(vilya, nenya); assertThat(elvesRings).doesNotContainSubsequence(vilya, narya);
- Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the given array isnull
.AssertionError
- if the actual group contains the given subsequence.
-
doesNotContainSubsequence
Verifies that the actual group does not contain the given subsequence, a subsequence is defined by an ordered group of values with possibly extra values between them.Example:
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertions will pass assertThat(elvesRings).doesNotContainSubsequence(newArrayList(nenya, vilya)); .doesNotContainSubsequence(newArrayList(narya, vilya)); // assertion will fail assertThat(elvesRings).doesNotContainSubsequence(newArrayList(vilya, nenya)); assertThat(elvesRings).doesNotContainSubsequence(newArrayList(vilya, narya));
- Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the given array isnull
.AssertionError
- if the actual group contains the given subsequence.
-
doesNotContain
Verifies that the actual group does not contain the given values.Example :
// an Iterable is used in the example but it would also work with an array Iterable<String> abc = newArrayList("a", "b", "c"); // assertions will pass assertThat(abc).doesNotContain("d") .doesNotContain("d", "e"); // assertions will fail assertThat(abc).doesNotContain("a"); assertThat(abc).doesNotContain("a", "b"); assertThat(abc).doesNotContain("c", "d");
- Parameters:
values
- the given values.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given argument isnull
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group isnull
.AssertionError
- if the actual group contains any of the given values.
-
doesNotHaveDuplicates
SELF doesNotHaveDuplicates()Verifies that the actual group does not contain duplicates.Example :
// an Iterable is used in the example but it would also work with an array Iterable<String> abc = newArrayList("a", "b", "c"); Iterable<String> lotsOfAs = newArrayList("a", "a", "a"); // assertion will pass assertThat(abc).doesNotHaveDuplicates(); // assertion will fail assertThat(lotsOfAs).doesNotHaveDuplicates();
- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the actual group contains duplicates.
-
startsWith
Verifies that the actual group starts with the given sequence of objects, without any other objects between them. Similar to
, but it also verifies that the first element in the sequence is also first element of the actual group.containsSequence(Object...)
Example :
// an Iterable is used in the example but it would also work with an array Iterable<String> abc = newArrayList("a", "b", "c"); // assertions will pass assertThat(abc).startsWith("a") .startsWith("a", "b"); // assertion will fail assertThat(abc).startsWith("c");
- Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
- Throws:
NullPointerException
- if the given argument isnull
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group isnull
.AssertionError
- if the actual group does not start with the given sequence of objects.
-
endsWith
Verifies that the actual group ends with the given sequence of objects, without any other objects between them. Similar to
, but it also verifies that the last element in the sequence is also last element of the actual group.containsSequence(Object...)
Example :
// an Iterable is used in the example but it would also work with an array Iterable<String> abc = newArrayList("a", "b", "c"); // assertions will pass assertThat(abc).endsWith("c") .endsWith("b", "c"); // assertions will fail assertThat(abc).endsWith("a"); assertThat(abc).endsWith("a", "b");
- Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
- Throws:
NullPointerException
- if the given argument isnull
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group isnull
.AssertionError
- if the actual group does not end with the given sequence of objects.
-
containsNull
SELF containsNull()Verifies that the actual group contains at least a null element.Example :
Iterable<String> abc = newArrayList("a", "b", "c"); Iterable<String> abNull = newArrayList("a", "b", null); // assertion will pass assertThat(abNull).containsNull(); // assertion will fail assertThat(abc).containsNull();
- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the actual group does not contain a null element.
-
doesNotContainNull
SELF doesNotContainNull()Verifies that the actual group does not contain null elements.Example :
Iterable<String> abc = newArrayList("a", "b", "c"); Iterable<String> abNull = newArrayList("a", "b", null); // assertion will pass assertThat(abc).doesNotContainNull(); // assertion will fail assertThat(abNull).doesNotContainNull();
- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual group isnull
.AssertionError
- if the actual group contains a null element.
-
are
Verifies that each element value satisfies the given condition.Example :
Iterable<String> abc = newArrayList("a", "b", "c"); Iterable<String> abcc = newArrayList("a", "b", "cc"); Condition<String> singleCharacterString = new Condition<>(s -> s.length() == 1, "single character String"); // assertion will pass assertThat(abc).are(singleCharacterString); // assertion will fail assertThat(abcc).are(singleCharacterString);
- Parameters:
condition
- the given condition.- Returns:
this
object.- Throws:
NullPointerException
- if the given condition isnull
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements do not satisfy the given condition.
-
areNot
Verifies that each element value does not satisfy the given condition.Example :
Iterable<String> abc = newArrayList("a", "b", "c"); Iterable<String> abcc = newArrayList("a", "b", "cc"); Condition<String> moreThanOneCharacter = = new Condition<>(s -> s.length() > 1, "more than one character"); // assertion will pass assertThat(abc).areNot(moreThanOneCharacter); // assertion will fail assertThat(abcc).areNot(moreThanOneCharacter);
- Parameters:
condition
- the given condition.- Returns:
this
object.- Throws:
NullPointerException
- if the given condition isnull
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements satisfy the given condition.
-
have
Verifies that all elements satisfy the given condition.Example :
Iterable<String> abc = newArrayList("a", "b", "c"); Iterable<String> abcc = newArrayList("a", "b", "cc"); Condition<String> onlyOneCharacter = = new Condition<>(s -> s.length() == 1, "only one character"); // assertion will pass assertThat(abc).have(onlyOneCharacter); // assertion will fail assertThat(abcc).have(onlyOneCharacter);
- Parameters:
condition
- the given condition.- Returns:
this
object.- Throws:
NullPointerException
- if the given condition isnull
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements do not satisfy the given condition.
-
doNotHave
Verifies that all elements do not satisfy the given condition.Example :
Iterable<String> abc = newArrayList("a", "b", "c"); Iterable<String> abcc = newArrayList("a", "b", "cc"); Condition<String> moreThanOneCharacter = = new Condition<>(s -> s.length() > 1, "more than one character"); // assertion will pass assertThat(abc).doNotHave(moreThanOneCharacter); // assertion will fail assertThat(abcc).doNotHave(moreThanOneCharacter);
- Parameters:
condition
- the given condition.- Returns:
this
object.- Throws:
NullPointerException
- if the given condition isnull
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements satisfy the given condition.
-
areAtLeast
Verifies that there are at least n elements in the actual group satisfying the given condition.Example :
Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3); Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number"); // assertion will pass oneTwoThree.areAtLeast(2, oddNumber); // assertion will fail oneTwoThree.areAtLeast(3, oddNumber);
- Parameters:
n
- the minimum number of times the condition should be verified.condition
- the given condition.- Returns:
this
object.- Throws:
NullPointerException
- if the given condition isnull
.AssertionError
- if an element can not be cast to T.AssertionError
- if the number of elements satisfying the given condition is < n.
-
areAtLeastOne
Verifies that there is at least one element in the actual group satisfying the given condition.This method is an alias for
areAtLeast(1, condition)
.Example:
// jedi is a Condition<String> assertThat(newLinkedHashSet("Luke", "Solo", "Leia")).areAtLeastOne(jedi);
- See Also:
-
areAtMost
Verifies that there are at most n elements in the actual group satisfying the given condition.Example :
Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3); Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number"); // assertions will pass oneTwoThree.areAtMost(2, oddNumber) .areAtMost(3, oddNumber); // assertion will fail oneTwoThree.areAtMost(1, oddNumber);
- Parameters:
n
- the number of times the condition should be at most verified.condition
- the given condition.- Returns:
this
object.- Throws:
NullPointerException
- if the given condition isnull
.AssertionError
- if an element cannot be cast to T.AssertionError
- if the number of elements satisfying the given condition is > n.
-
areExactly
Verifies that there are exactly n elements in the actual group satisfying the given condition.Example :
Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3); Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number"); // assertion will pass oneTwoThree.areExactly(2, oddNumber); // assertions will fail oneTwoThree.areExactly(1, oddNumber); oneTwoThree.areExactly(3, oddNumber);
- Parameters:
n
- the exact number of times the condition should be verified.condition
- the given condition.- Returns:
this
object.- Throws:
NullPointerException
- if the given condition isnull
.AssertionError
- if an element cannot be cast to T.AssertionError
- if the number of elements satisfying the given condition is ≠ n.
-
haveAtLeastOne
Verifies that there is at least one element in the actual group satisfying the given condition.This method is an alias for
haveAtLeast(1, condition)
.Example:
Iterable<BasketBallPlayer> bullsPlayers = newArrayList(butler, rose); // potentialMvp is a Condition<BasketBallPlayer> assertThat(bullsPlayers).haveAtLeastOne(potentialMvp);
- See Also:
-
haveAtLeast
Verifies that there are at least n elements in the actual group satisfying the given condition.Example :
This method is an alias forIterable<Integer> oneTwoThree = newArrayList(1, 2, 3); Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number"); // assertion will pass oneTwoThree.haveAtLeast(2, oddNumber); // assertion will fail oneTwoThree.haveAtLeast(3, oddNumber);
areAtLeast(int, Condition)
. -
haveAtMost
Verifies that there are at most n elements in the actual group satisfying the given condition.Example :
This method is an aliasIterable<Integer> oneTwoThree = newArrayList(1, 2, 3); Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number"); // assertions will pass oneTwoThree.haveAtMost(2, oddNumber); oneTwoThree.haveAtMost(3, oddNumber); // assertion will fail oneTwoThree.haveAtMost(1, oddNumber);
areAtMost(int, Condition)
. -
haveExactly
Verifies that there are exactly n elements in the actual group satisfying the given condition.Example :
This method is an aliasIterable<Integer> oneTwoThree = newArrayList(1, 2, 3); Condition<Integer> oddNumber = new Condition<>(value % 2 == 1, "odd number"); // assertion will pass oneTwoThree.haveExactly(2, oddNumber); // assertions will fail oneTwoThree.haveExactly(1, oddNumber); oneTwoThree.haveExactly(3, oddNumber);
areExactly(int, Condition)
. -
containsAll
Verifies that the actual group contains all the elements of givenIterable
, in any order.Example :
Iterable<String> abc = Arrays.asList("a", "b", "c"); // assertions will pass assertThat(abc).containsAll(Arrays.asList("b", "c")) .containsAll(Arrays.asList("a", "b", "c")); // assertions will fail assertThat(abc).containsAll(Arrays.asList("d")); assertThat(abc).containsAll(Arrays.asList("a", "b", "c", "d"));
- Parameters:
iterable
- the givenIterable
we will get elements from.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given argument isnull
.AssertionError
- if the actual group isnull
.AssertionError
- if the actual group does not contain all the elements of givenIterable
.
-
hasOnlyElementsOfTypes
Verifies that all elements of the actual group are instances of the given types.Example :
Iterable<? extends Object> objects = Arrays.asList("foo", new StringBuilder()); // assertions will pass assertThat(objects).hasOnlyElementsOfTypes(CharSequence.class) .hasOnlyElementsOfTypes(String.class, StringBuilder.class); // assertions will fail assertThat(objects).hasOnlyElementsOfTypes(Number.class); assertThat(objects).hasOnlyElementsOfTypes(String.class, Number.class); assertThat(objects).hasOnlyElementsOfTypes(String.class);
- Parameters:
types
- the expected classes and interfaces- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given argument isnull
.AssertionError
- if the actual group isnull
.AssertionError
- if not all elements of the actual group are instances of one of the given types- Since:
- 2.7.0 / 3.7.0
-
hasAtLeastOneElementOfType
Verifies that at least one element in the actualObject
group has the specified type (matching includes subclasses of the given type).Example:
Number[] numbers = { 2, 6L, 8.0 }; // successful assertion: assertThat(numbers).hasAtLeastOneElementOfType(Long.class); // assertion failure: assertThat(numbers).hasAtLeastOneElementOfType(Float.class);
- Parameters:
expectedType
- the expected type.- Returns:
- this assertion object.
- Throws:
NullPointerException
- if the given type isnull
.AssertionError
- if the actualObject
group does not have any elements of the given type.
-
hasOnlyElementsOfType
Verifies that all the elements in the actualObject
group belong to the specified type (matching includes subclasses of the given type).Example:
Number[] numbers = { 2, 6, 8 }; // successful assertion: assertThat(numbers).hasOnlyElementsOfType(Integer.class); // assertion failure: assertThat(numbers).hasOnlyElementsOfType(Long.class);
- Parameters:
expectedType
- the expected type.- Returns:
- this assertion object.
- Throws:
NullPointerException
- if the given type isnull
.AssertionError
- if one element is not of the expected type.
-
containsExactlyElementsOf
Same ascontainsExactly(Object...)
but handle theIterable
to array conversion : verifies that actual contains all the elements of the given iterable and nothing else in the same order.Example :
Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertion will pass assertThat(elvesRings).containsExactlyElementsOf(newLinkedList(vilya, nenya, narya)); // assertion will fail as actual and expected order differ assertThat(elvesRings).containsExactlyElementsOf(newLinkedList(nenya, vilya, narya));
- Parameters:
iterable
- the givenIterable
we will get elements from.
-
containsOnlyElementsOf
Same semantic ascontainsOnly(Object[])
: verifies that actual contains all the elements of the given iterable and nothing else, in any order.Example :
Iterable<Ring> rings = newArrayList(nenya, vilya); // assertion will pass assertThat(rings).containsOnlyElementsOf(newLinkedList(nenya, vilya)) .containsOnlyElementsOf(newLinkedList(nenya, nenya, vilya, vilya)); // assertion will fail as actual does not contain narya assertThat(rings).containsOnlyElementsOf(newLinkedList(nenya, vilya, narya)); // assertion will fail as actual contains nenya assertThat(rings).containsOnlyElementsOf(newLinkedList(vilya));
- Parameters:
iterable
- the givenIterable
we will get elements from.
-
hasSameElementsAs
An alias ofcontainsOnlyElementsOf(Iterable)
: verifies that actual contains all the elements of the given iterable and nothing else, in any order. Example:Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertions will pass: assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, narya, vilya)) .hasSameElementsAs(newArrayList(nenya, narya, vilya, nenya)); // assertions will fail: assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, narya)); assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, narya, vilya, oneRing));
- Parameters:
iterable
- the Iterable whose elements we expect to be present- Returns:
- this assertion object
- Throws:
AssertionError
- if the actual group isnull
NullPointerException
- if the givenIterable
isnull
AssertionError
- if the actualIterable
does not have the same elements, in any order, as the givenIterable
-
doesNotContainAnyElementsOf
Verifies that actual does not contain any elements of the givenIterable
(i.e. none).Example:
Iterable<String> abc = newArrayList("a", "b", "c"); // assertion succeeds: assertThat(actual).doesNotContainAnyElementsOf(newArrayList("d", "e")); // assertion fails: assertThat(actual).doesNotContainAnyElementsOf(newArrayList("d", "e", "a"));
- Parameters:
iterable
- theIterable
whose elements must not be in the actual group.- Returns:
this
assertion object.- Throws:
NullPointerException
- if the given argument isnull
.IllegalArgumentException
- if the given argument is an empty iterable.AssertionError
- if the actual group isnull
.AssertionError
- if the actual group contains some elements of the givenIterable
.
-
isSubsetOf
Verifies that all the elements of actual are present in the givenIterable
.Example:
// an Iterable is used in the example but it would also work with an array List<Ring> ringsOfPower = newArrayList(oneRing, vilya, nenya, narya, dwarfRing, manRing); Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertion will pass: assertThat(elvesRings).isSubsetOf(ringsOfPower); // assertion will fail: assertThat(elvesRings).isSubsetOf(newArrayList(nenya, narya));
- Parameters:
values
- theIterable
that should contain all actual elements.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualIterable
isnull
.NullPointerException
- if the givenIterable
isnull
.AssertionError
- if the actualIterable
is not subset of setIterable
.
-
isSubsetOf
Verifies that all the elements of actual are present in the given values.Example:
// an Iterable is used in the example but it would also work with an array Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); // assertions will pass: assertThat(elvesRings).isSubsetOf(vilya, nenya, narya) .isSubsetOf(vilya, nenya, narya, dwarfRing); // assertions will fail: assertThat(elvesRings).isSubsetOf(vilya, nenya); assertThat(elvesRings).isSubsetOf(vilya, nenya, dwarfRing);
- Parameters:
values
- the values that should be used for checking the elements of actual.- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actualIterable
isnull
.AssertionError
- if the actualIterable
is not subset of the given values.
-
allMatch
Verifies that all the elements of actual match the givenPredicate
.Example :
Note that you can achieve the same result withIterable<String> abc = newArrayList("a", "b", "c"); Iterable<String> abcc = newArrayList("a", "b", "cc"); // assertion will pass assertThat(abc).allMatch(s -> s.length() == 1); // assertion will fail assertThat(abcc).allMatch(s -> s.length() == 1);
are(Condition)
orhave(Condition)
.- Parameters:
predicate
- the givenPredicate
.- Returns:
this
object.- Throws:
NullPointerException
- if the given predicate isnull
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements don't satisfy the given predicate.
-
allMatch
Verifies that all the elements of actual match the givenPredicate
. The predicate description is used to get an informative error message.Example :
The message of the failed assertion would be:Iterable<String> abc = newArrayList("a", "b", "c"); Iterable<String> abcc = newArrayList("a", "b", "cc"); // assertion will pass assertThat(abc).allMatch(s -> s.length() == 1, "length of 1"); // assertion will fail assertThat(abcc).allMatch(s -> s.length() == 1, "length of 1");
Expecting all elements of: <["a", "b", "cc"]> to match 'length of 1' predicate but this element did not: <"cc">
- Parameters:
predicate
- the givenPredicate
.predicateDescription
- a description of thePredicate
used in the error message- Returns:
this
object.- Throws:
NullPointerException
- if the given predicate isnull
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements don't satisfy the given predicate.- Since:
- 3.6.0
-
allSatisfy
Verifies that all the elements satisfy given requirements expressed as aConsumer
.This is useful to perform a group of assertions on elements.
Example:
assertThat(myIcelanderFriends).allSatisfy(person -> { assertThat(person.getCountry()).isEqualTo("Iceland"); assertThat(person.getPhoneCountryCode()).isEqualTo("+354"); });
- Parameters:
requirements
- the givenConsumer
.- Returns:
this
object.- Throws:
NullPointerException
- if the givenConsumer
isnull
.AssertionError
- if one or more elements don't satisfy given requirements.- Since:
- 3.6.0
-
anySatisfy
Verifies that at least one element satisfies the given requirements expressed as aConsumer
.This is useful to check that a group of assertions is verified by (at least) one element.
If the group of elements to assert is empty, the assertion will fail.
Example:
// assume that one icelander in myIcelanderFriends has a name finishing by 'son' assertThat(myIcelanderFriends).anySatisfy(person -> { assertThat(person.getCountry()).isEqualTo("Iceland"); assertThat(person.getSurname()).endsWith("son"); }); // assertion fails for empty group, whatever the requirements are. assertThat(emptyGroup).anySatisfy($ -> assertThat(true).isTrue());
- Parameters:
requirements
- the givenConsumer
.- Returns:
this
object.- Throws:
NullPointerException
- if the givenConsumer
isnull
.AssertionError
- none elements satisfy the given requirements.- Since:
- 3.7.0
-