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.public interface ObjectEnumerableAssert<SELF extends ObjectEnumerableAssert<SELF,ELEMENT>,ELEMENT> extends EnumerableAssert<SELF,ELEMENT>
Modifier and Type | Method and Description |
---|---|
SELF |
allMatch(Predicate<? super ELEMENT> predicate)
Verifies that all the elements of actual match the given
Predicate . |
SELF |
allMatch(Predicate<? super ELEMENT> predicate,
String predicateDescription)
Verifies that all the elements of actual match the given
Predicate . |
SELF |
allSatisfy(Consumer<? super ELEMENT> requirements)
Verifies that all the elements satisfy given requirements expressed as a
Consumer . |
SELF |
anySatisfy(Consumer<? super ELEMENT> requirements)
Verifies that at least one element satisfies the given requirements expressed as a
Consumer . |
SELF |
are(Condition<? super ELEMENT> condition)
Verifies that each element value satisfies the given condition.
|
SELF |
areAtLeast(int n,
Condition<? super ELEMENT> condition)
Verifies that there are at least n elements in the actual group satisfying the given condition.
|
SELF |
areAtLeastOne(Condition<? super ELEMENT> condition)
Verifies that there is at least one element in the actual group satisfying the given condition.
|
SELF |
areAtMost(int n,
Condition<? super ELEMENT> condition)
Verifies that there are at most n elements in the actual group satisfying the given condition.
|
SELF |
areExactly(int n,
Condition<? super ELEMENT> condition)
Verifies that there are exactly n elements in the actual group satisfying the given condition.
|
SELF |
areNot(Condition<? super ELEMENT> condition)
Verifies that each element value does not satisfy the given condition.
|
SELF |
contains(ELEMENT... values)
Verifies that the actual group contains the given values, in any order.
|
SELF |
containsAll(Iterable<? extends ELEMENT> iterable)
Verifies that the actual group contains all the elements of given
Iterable , in any order. |
SELF |
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. |
SELF |
containsExactlyElementsOf(Iterable<? extends ELEMENT> iterable)
Same as
containsExactly(Object...) but handle the Iterable to array conversion : verifies that
actual contains all the elements of the given iterable and nothing else in the same order. |
SELF |
containsExactlyInAnyOrder(ELEMENT... values)
Verifies that the actual group contains exactly the given values and nothing else, in any order.
|
SELF |
containsNull()
Verifies that the actual group contains at least a null element.
|
SELF |
containsOnly(ELEMENT... values)
Verifies that the actual group contains only the given values and nothing else, in any order.
|
SELF |
containsOnlyElementsOf(Iterable<? extends ELEMENT> iterable)
Same semantic as
containsOnly(Object[]) : verifies that actual contains all the elements of the given
iterable and nothing else, in any order. |
SELF |
containsOnlyOnce(ELEMENT... values)
Verifies that the actual group contains the given values only once.
|
SELF |
containsSequence(ELEMENT... sequence)
Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.
|
SELF |
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.
|
SELF |
containsSubsequence(ELEMENT... sequence)
Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).
|
SELF |
containsSubsequence(Iterable<? extends ELEMENT> sequence)
Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).
|
SELF |
doesNotContain(ELEMENT... values)
Verifies that the actual group does not contain the given values.
|
SELF |
doesNotContainAnyElementsOf(Iterable<? extends ELEMENT> iterable)
Verifies that actual does not contain any elements of the given
Iterable (i.e. |
SELF |
doesNotContainNull()
Verifies that the actual group does not contain null elements.
|
SELF |
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.
|
SELF |
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.
|
SELF |
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.
|
SELF |
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.
|
SELF |
doesNotHaveDuplicates()
Verifies that the actual group does not contain duplicates.
|
SELF |
doNotHave(Condition<? super ELEMENT> condition)
Verifies that all elements do not satisfy the given condition.
|
SELF |
endsWith(ELEMENT... sequence)
Verifies that the actual group ends with the given sequence of objects, without any other objects between them.
|
SELF |
hasAtLeastOneElementOfType(Class<?> expectedType)
Verifies that at least one element in the actual
Object group has the specified type (matching
includes subclasses of the given type). |
SELF |
hasOnlyElementsOfType(Class<?> expectedType)
Verifies that all the elements in the actual
Object group belong to the specified type (matching includes
subclasses of the given type). |
SELF |
hasOnlyElementsOfTypes(Class<?>... types)
Verifies that all elements of the actual group are instances of the given types.
|
SELF |
hasSameElementsAs(Iterable<? extends ELEMENT> iterable)
An alias of
containsOnlyElementsOf(Iterable) : verifies that actual contains all the elements of the
given iterable and nothing else, in any order. |
SELF |
have(Condition<? super ELEMENT> condition)
Verifies that all elements satisfy the given condition.
|
SELF |
haveAtLeast(int n,
Condition<? super ELEMENT> condition)
Verifies that there are at least n elements in the actual group satisfying the given condition.
|
SELF |
haveAtLeastOne(Condition<? super ELEMENT> condition)
Verifies that there is at least one element in the actual group satisfying the given condition.
|
SELF |
haveAtMost(int n,
Condition<? super ELEMENT> condition)
Verifies that there are at most n elements in the actual group satisfying the given condition.
|
SELF |
haveExactly(int n,
Condition<? super ELEMENT> condition)
Verifies that there are exactly n elements in the actual group satisfying the given condition.
|
SELF |
isSubsetOf(ELEMENT... values)
Verifies that all the elements of actual are present in the given values.
|
SELF |
isSubsetOf(Iterable<? extends ELEMENT> values)
Verifies that all the elements of actual are present in the given
Iterable . |
SELF |
startsWith(ELEMENT... sequence)
Verifies that the actual group starts with the given sequence of objects, without any other objects between them.
|
hasSameSizeAs, hasSameSizeAs, hasSize, isEmpty, isNotEmpty, isNullOrEmpty, usingDefaultElementComparator, usingElementComparator
SELF contains(ELEMENT... values)
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");
values
- the given values.this
assertion object.NullPointerException
- if the given argument is null
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group is null
.AssertionError
- if the actual group does not contain the given values.SELF containsOnly(ELEMENT... values)
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");
values
- the given values.this
assertion object.NullPointerException
- if the given argument is null
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group is null
.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.SELF containsOnlyOnce(ELEMENT... values)
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");
values
- the given values.this
assertion object.NullPointerException
- if the given argument is null
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group is null
.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.SELF containsExactly(ELEMENT... values)
HashSet
, prefer containsOnly(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);
values
- the given values.this
assertion object.NullPointerException
- if the given argument is null
.AssertionError
- if the actual group is null
.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.SELF containsExactlyInAnyOrder(ELEMENT... values)
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);
values
- the given values.this
assertion object.NullPointerException
- if the given argument is null
.AssertionError
- if the actual group is null
.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.SELF containsSequence(ELEMENT... sequence)
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);
sequence
- the sequence of objects to look for.AssertionError
- if the actual group is null
.AssertionError
- if the given array is null
.AssertionError
- if the actual group does not contain the given sequence.SELF containsSequence(Iterable<? extends ELEMENT> sequence)
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));
sequence
- the sequence of objects to look for.AssertionError
- if the actual group is null
.AssertionError
- if the given array is null
.AssertionError
- if the actual group does not contain the given sequence.SELF doesNotContainSequence(ELEMENT... sequence)
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);
sequence
- the sequence of objects to look for.AssertionError
- if the actual group is null
.AssertionError
- if the given array is null
.AssertionError
- if the actual group contains the given sequence.SELF doesNotContainSequence(Iterable<? extends ELEMENT> sequence)
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));
sequence
- the sequence of objects to look for.AssertionError
- if the actual group is null
.AssertionError
- if the given array is null
.AssertionError
- if the actual group contains the given sequence.SELF containsSubsequence(ELEMENT... sequence)
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);
sequence
- the sequence of objects to look for.AssertionError
- if the actual group is null
.AssertionError
- if the given array is null
.AssertionError
- if the actual group does not contain the given subsequence.SELF containsSubsequence(Iterable<? extends ELEMENT> sequence)
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));
sequence
- the sequence of objects to look for.AssertionError
- if the actual group is null
.AssertionError
- if the given array is null
.AssertionError
- if the actual group does not contain the given subsequence.SELF doesNotContainSubsequence(ELEMENT... sequence)
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);
sequence
- the sequence of objects to look for.AssertionError
- if the actual group is null
.AssertionError
- if the given array is null
.AssertionError
- if the actual group contains the given subsequence.SELF doesNotContainSubsequence(Iterable<? extends ELEMENT> sequence)
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));
sequence
- the sequence of objects to look for.AssertionError
- if the actual group is null
.AssertionError
- if the given array is null
.AssertionError
- if the actual group contains the given subsequence.SELF doesNotContain(ELEMENT... 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");
values
- the given values.this
assertion object.NullPointerException
- if the given argument is null
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group is null
.AssertionError
- if the actual group contains any of the given values.SELF doesNotHaveDuplicates()
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();
this
assertion object.AssertionError
- if the actual group is null
.AssertionError
- if the actual group contains duplicates.SELF startsWith(ELEMENT... sequence)
containsSequence(Object...)
, but it also verifies that the first element in the
sequence is also first element of the actual group.
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");
sequence
- the sequence of objects to look for.NullPointerException
- if the given argument is null
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group is null
.AssertionError
- if the actual group does not start with the given sequence of objects.SELF endsWith(ELEMENT... sequence)
containsSequence(Object...)
, but it also verifies that the last element in the
sequence is also last element of the actual group.
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");
sequence
- the sequence of objects to look for.NullPointerException
- if the given argument is null
.IllegalArgumentException
- if the given argument is an empty array.AssertionError
- if the actual group is null
.AssertionError
- if the actual group does not end with the given sequence of objects.SELF containsNull()
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();
this
assertion object.AssertionError
- if the actual group is null
.AssertionError
- if the actual group does not contain a null element.SELF doesNotContainNull()
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();
this
assertion object.AssertionError
- if the actual group is null
.AssertionError
- if the actual group contains a null element.SELF are(Condition<? super ELEMENT> 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);
condition
- the given condition.this
object.NullPointerException
- if the given condition is null
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements do not satisfy the given condition.SELF areNot(Condition<? super ELEMENT> 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);
condition
- the given condition.this
object.NullPointerException
- if the given condition is null
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements satisfy the given condition.SELF have(Condition<? super ELEMENT> 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);
condition
- the given condition.this
object.NullPointerException
- if the given condition is null
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements do not satisfy the given condition.SELF doNotHave(Condition<? super ELEMENT> 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);
condition
- the given condition.this
object.NullPointerException
- if the given condition is null
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements satisfy the given condition.SELF areAtLeast(int n, Condition<? super ELEMENT> 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);
n
- the minimum number of times the condition should be verified.condition
- the given condition.this
object.NullPointerException
- if the given condition is null
.AssertionError
- if an element can not be cast to T.AssertionError
- if the number of elements satisfying the given condition is < n.SELF areAtLeastOne(Condition<? super ELEMENT> condition)
This method is an alias for areAtLeast(1, condition)
.
Example:
// jedi is a Condition<String>
assertThat(newLinkedHashSet("Luke", "Solo", "Leia")).areAtLeastOne(jedi);
haveAtLeast(int, Condition)
SELF areAtMost(int n, Condition<? super ELEMENT> 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);
n
- the number of times the condition should be at most verified.condition
- the given condition.this
object.NullPointerException
- if the given condition is null
.AssertionError
- if an element cannot be cast to T.AssertionError
- if the number of elements satisfying the given condition is > n.SELF areExactly(int n, Condition<? super ELEMENT> 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);
n
- the exact number of times the condition should be verified.condition
- the given condition.this
object.NullPointerException
- if the given condition is null
.AssertionError
- if an element cannot be cast to T.AssertionError
- if the number of elements satisfying the given condition is ≠ n.SELF haveAtLeastOne(Condition<? super ELEMENT> 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);
haveAtLeast(int, Condition)
SELF haveAtLeast(int n, Condition<? super ELEMENT> condition)
Example :
Iterable<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);
This method is an alias for areAtLeast(int, Condition)
.SELF haveAtMost(int n, Condition<? super ELEMENT> condition)
Example :
Iterable<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);
This method is an alias areAtMost(int, Condition)
.SELF haveExactly(int n, Condition<? super ELEMENT> condition)
Example :
Iterable<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);
This method is an alias areExactly(int, Condition)
.SELF containsAll(Iterable<? extends ELEMENT> iterable)
Iterable
, 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"));
iterable
- the given Iterable
we will get elements from.this
assertion object.NullPointerException
- if the given argument is null
.AssertionError
- if the actual group is null
.AssertionError
- if the actual group does not contain all the elements of given Iterable
.SELF hasOnlyElementsOfTypes(Class<?>... 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);
types
- the expected classes and interfacesthis
assertion object.NullPointerException
- if the given argument is null
.AssertionError
- if the actual group is null
.AssertionError
- if not all elements of the actual group are instances of one of the given typesSELF hasAtLeastOneElementOfType(Class<?> expectedType)
Object
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);
expectedType
- the expected type.NullPointerException
- if the given type is null
.AssertionError
- if the actual Object
group does not have any elements of the given type.SELF hasOnlyElementsOfType(Class<?> expectedType)
Object
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);
expectedType
- the expected type.NullPointerException
- if the given type is null
.AssertionError
- if one element is not of the expected type.SELF containsExactlyElementsOf(Iterable<? extends ELEMENT> iterable)
containsExactly(Object...)
but handle the Iterable
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));
iterable
- the given Iterable
we will get elements from.SELF containsOnlyElementsOf(Iterable<? extends ELEMENT> iterable)
containsOnly(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));
iterable
- the given Iterable
we will get elements from.SELF hasSameElementsAs(Iterable<? extends ELEMENT> iterable)
containsOnlyElementsOf(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));
iterable
- the Iterable whose elements we expect to be presentAssertionError
- if the actual group is null
NullPointerException
- if the given Iterable
is null
AssertionError
- if the actual Iterable
does not have the same elements, in any order, as the given
Iterable
SELF doesNotContainAnyElementsOf(Iterable<? extends ELEMENT> iterable)
Iterable
(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"));
iterable
- the Iterable
whose elements must not be in the actual group.this
assertion object.NullPointerException
- if the given argument is null
.IllegalArgumentException
- if the given argument is an empty iterable.AssertionError
- if the actual group is null
.AssertionError
- if the actual group contains some elements of the given Iterable
.SELF isSubsetOf(Iterable<? extends ELEMENT> values)
Iterable
.
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));
values
- the Iterable
that should contain all actual elements.AssertionError
- if the actual Iterable
is null
.NullPointerException
- if the given Iterable
is null
.AssertionError
- if the actual Iterable
is not subset of set Iterable
.SELF isSubsetOf(ELEMENT... 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);
values
- the values that should be used for checking the elements of actual.AssertionError
- if the actual Iterable
is null
.AssertionError
- if the actual Iterable
is not subset of the given values.SELF allMatch(Predicate<? super ELEMENT> predicate)
Predicate
.
Example :
Iterable<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);
Note that you can achieve the same result with are(Condition)
or have(Condition)
.predicate
- the given Predicate
.this
object.NullPointerException
- if the given predicate is null
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements don't satisfy the given predicate.SELF allMatch(Predicate<? super ELEMENT> predicate, String predicateDescription)
Predicate
. The predicate description is used
to get an informative error message.
Example :
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");
The message of the failed assertion would be:
Expecting all elements of:
<["a", "b", "cc"]>
to match 'length of 1' predicate but this element did not:
<"cc">
predicate
- the given Predicate
.predicateDescription
- a description of the Predicate
used in the error messagethis
object.NullPointerException
- if the given predicate is null
.AssertionError
- if an element cannot be cast to T.AssertionError
- if one or more elements don't satisfy the given predicate.SELF allSatisfy(Consumer<? super ELEMENT> requirements)
Consumer
.
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");
});
requirements
- the given Consumer
.this
object.NullPointerException
- if the given Consumer
is null
.AssertionError
- if one or more elements don't satisfy given requirements.SELF anySatisfy(Consumer<? super ELEMENT> requirements)
Consumer
.
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());
requirements
- the given Consumer
.this
object.NullPointerException
- if the given Consumer
is null
.AssertionError
- none elements satisfy the given requirements.Copyright © 2014–2017 AssertJ. All rights reserved.