Class ObjectArrayAssert<ELEMENT>
- Type Parameters:
ELEMENT
- the type of elements of the "actual" value.
- All Implemented Interfaces:
ArraySortedAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
,ELEMENT>, ELEMENT> Assert<ObjectArrayAssert<ELEMENT>,
,ELEMENT[]> Descriptable<ObjectArrayAssert<ELEMENT>>
,EnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
,ELEMENT>, ELEMENT> ExtensionPoints<ObjectArrayAssert<ELEMENT>,
,ELEMENT[]> IndexedObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
,ELEMENT>, ELEMENT> ObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT>
To create an instance of this class, invoke
.
Assertions.assertThat(Object[])
-
Field Summary
Fields inherited from class org.assertj.core.api.AbstractObjectArrayAssert
arrays, comparatorsByType, comparatorsForElementPropertyOrFieldNames, comparatorsForElementPropertyOrFieldTypes, iterables
Fields inherited from class org.assertj.core.api.AbstractAssert
actual, assertionErrorCreator, conditions, info, myself, objects, throwUnsupportedExceptionOnEquals
-
Constructor Summary
ConstructorsConstructorDescriptionObjectArrayAssert
(ELEMENT[] actual) ObjectArrayAssert
(AtomicReferenceArray<ELEMENT> actual) -
Method Summary
Modifier and TypeMethodDescriptionfinal ObjectArrayAssert<ELEMENT>
Verifies that the actual array contains the given values, in any order.final ObjectArrayAssert<ELEMENT>
containsAnyOf
(ELEMENT... values) Verifies that the actual array contains at least one of the given values.final ObjectArrayAssert<ELEMENT>
containsExactly
(ELEMENT... values) Verifies that the actual array contains exactly the given values and nothing else, in order.final ObjectArrayAssert<ELEMENT>
containsExactlyInAnyOrder
(ELEMENT... values) Verifies that the actual array contains exactly the given values and nothing else, in any order.final ObjectArrayAssert<ELEMENT>
containsOnly
(ELEMENT... values) Verifies that the actual array contains only the given values and nothing else, in any order and ignoring duplicates (i.e.final ObjectArrayAssert<ELEMENT>
containsOnlyOnce
(ELEMENT... values) Verifies that the actual array contains the given values only once.final ObjectArrayAssert<ELEMENT>
containsSequence
(ELEMENT... sequence) Verifies that the actual array contains the given sequence in the correct order and without extra values between the sequence values.final ObjectArrayAssert<ELEMENT>
containsSubsequence
(ELEMENT... sequence) Verifies that the actual array contains the given subsequence in the correct order (possibly with other values between them).final ObjectArrayAssert<ELEMENT>
doesNotContain
(ELEMENT... values) Verifies that the actual array does not contain the given values.final ObjectArrayAssert<ELEMENT>
doesNotContainSequence
(ELEMENT... sequence) Verifies that the actual array does not contain the given sequence in the given order and without extra values between the sequence values.final ObjectArrayAssert<ELEMENT>
doesNotContainSubsequence
(ELEMENT... sequence) Verifies that the actual array does not contain the given subsequence in the correct order (possibly with other values between them).final ObjectArrayAssert<ELEMENT>
Verifies that the actual array ends with the given sequence of objects, without any other objects between them.final AbstractListAssert<?,
List<? extends Tuple>, Tuple, ObjectAssert<Tuple>> extracting
(Function<? super ELEMENT, ?>... extractors) final ObjectArrayAssert<ELEMENT>
isSubsetOf
(ELEMENT... values) Verifies that all elements of actual are present in the given values.protected ObjectArrayAssert<ELEMENT>
newObjectArrayAssert
(ELEMENT[] array) final ObjectArrayAssert<ELEMENT>
satisfiesExactly
(Consumer<? super ELEMENT>... requirements) Verifies that each element satisfies the requirements corresponding to its index, so the first element must satisfy the first requirements, the second element the second requirements etc...final ObjectArrayAssert<ELEMENT>
satisfiesExactlyInAnyOrder
(Consumer<? super ELEMENT>... requirements) Verifies that at least one combination of iterable elements exists that satisfies the consumers in order (there must be as many consumers as iterable elements and once a consumer is matched it cannot be reused to match other elements).Methods inherited from class org.assertj.core.api.AbstractObjectArrayAssert
allMatch, allMatch, allSatisfy, anyMatch, anySatisfy, are, areAtLeast, areAtLeastOne, areAtMost, areExactly, areNot, as, as, contains, containsAll, containsAnyElementsOf, containsExactlyElementsOf, containsExactlyInAnyOrderElementsOf, containsNull, containsOnlyElementsOf, containsOnlyNulls, containsOnlyOnceElementsOf, containsSequence, containsSubsequence, doesNotContain, doesNotContainAnyElementsOf, doesNotContainNull, doesNotContainSequence, doesNotContainSubsequence, doesNotHaveAnyElementsOfTypes, doesNotHaveDuplicates, doNotHave, endsWith, extracting, extracting, extracting, extracting, extracting, extractingResultOf, extractingResultOf, filteredOn, filteredOn, filteredOn, filteredOn, filteredOn, filteredOnAssertions, filteredOnNull, flatExtracting, flatExtracting, flatExtracting, getComparatorsByType, getComparatorsForElementPropertyOrFieldTypes, hasAtLeastOneElementOfType, hasOnlyElementsOfType, hasOnlyElementsOfTypes, hasOnlyOneElementSatisfying, hasSameElementsAs, hasSameSizeAs, hasSameSizeAs, hasSize, hasSizeBetween, hasSizeGreaterThan, hasSizeGreaterThanOrEqualTo, hasSizeLessThan, hasSizeLessThanOrEqualTo, have, haveAtLeast, haveAtLeastOne, haveAtMost, haveExactly, inBinary, inHexadecimal, isEmpty, isNotEmpty, isNullOrEmpty, isSorted, isSortedAccordingTo, isSubsetOf, newListAssertInstance, noneMatch, noneSatisfy, startsWith, usingComparatorForElementFieldsWithNames, usingComparatorForElementFieldsWithType, usingComparatorForType, usingDefaultElementComparator, usingElementComparator, usingElementComparatorIgnoringFields, usingElementComparatorOnFields, usingFieldByFieldElementComparator, usingRecursiveComparison, usingRecursiveComparison, usingRecursiveFieldByFieldElementComparator, withAssertionState, withComparatorsForElementPropertyOrFieldNames, withComparatorsForElementPropertyOrFieldTypes, withIterables, withObjectArrays, withTypeComparators, zipSatisfy
Methods inherited from class org.assertj.core.api.AbstractAssert
asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, is, isElementOfCustomAssert, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOf, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
Methods inherited from interface org.assertj.core.api.Descriptable
as, describedAs
-
Constructor Details
-
ObjectArrayAssert
-
ObjectArrayAssert
-
-
Method Details
-
newObjectArrayAssert
- Specified by:
newObjectArrayAssert
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>
-
extracting
@SafeVarargs public final AbstractListAssert<?,List<? extends Tuple>, extractingTuple, ObjectAssert<Tuple>> (Function<? super ELEMENT, ?>... extractors) Description copied from class:AbstractObjectArrayAssert
Use the givenFunction
s to extract the values from the array's elements into a new list composed ofTuple
s (a simple data structure containing the extracted values), this new list becoming the object under test.It allows you to test values from the array's elements instead of testing the elements themselves, which sometimes can be much less work!
The
Tuple
data corresponds to the extracted values from the arrays's elements, for instance if you pass functions extracting "id", "name" and "email" values then eachTuple
's data will be composed of an id, a name and an email extracted from the element of the initial array (the Tuple's data order is the same as the given functions order).Let's take a look at an example to make things clearer :
You can use lambda expression or a method reference to extract the expected values.// Build an array of TolkienCharacter, a TolkienCharacter has a name (String) and a Race (a class) // they can be public field or properties, both works when extracting their values. TolkienCharacter[] fellowshipOfTheRing = new TolkienCharacter[] { new TolkienCharacter("Frodo", 33, HOBBIT), new TolkienCharacter("Sam", 38, HOBBIT), new TolkienCharacter("Gandalf", 2020, MAIA), new TolkienCharacter("Legolas", 1000, ELF), new TolkienCharacter("Pippin", 28, HOBBIT), new TolkienCharacter("Gimli", 139, DWARF), new TolkienCharacter("Aragorn", 87, MAN, new TolkienCharacter("Boromir", 37, MAN) }; // let's verify 'name', 'age' and Race of some TolkienCharacter in fellowshipOfTheRing : assertThat(fellowshipOfTheRing).extracting(TolkienCharacter::getName, character -> character.getAge(), TolkienCharacter::getRace) .containsOnly(tuple("Frodo", 33, HOBBIT), tuple("Sam", 38, HOBBIT), tuple("Gandalf", 2020, MAIA), tuple("Legolas", 1000, ELF), tuple("Pippin", 28, HOBBIT), tuple("Gimli", 139, DWARF), tuple("Aragorn", 87, MAN), tuple("Boromir", 37, MAN));
Use
Tuple.tuple(Object...)
to initialize the expected values.Note that the order of the extracted tuples list is consistent with the iteration order of the array under test, for example if it's a
HashSet
, you won't be able to make any assumptions on the extracted tuples order.- Overrides:
extracting
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
extractors
- the extractor functions to extract a value from an element of the array under test.- Returns:
- a new assertion object whose object under test is the list of Tuples containing the extracted values.
-
contains
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array contains the given values, in any order.Example :
String[] abc = {"a", "b", "c"}; // assertions will pass assertThat(abc).contains("b", "a"); assertThat(abc).contains("b", "a", "b"); // assertions will fail assertThat(abc).contains("d"); assertThat(abc).contains("c", "d");
- Specified by:
contains
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
contains
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
values
- the given values.- Returns:
this
assertion object.
-
containsOnly
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array contains only the given values and nothing else, in any order and ignoring duplicates (i.e. once a value is found, its duplicates are also considered found).If you need to check exactly the elements and their duplicates use:
containsExactly(Object...)
if the order does mattercontainsExactlyInAnyOrder(Object...)
if the order does not matter
String[] abc = {"a", "b", "c"}; // assertions succeed assertThat(abc).containsOnly("c", "b", "a"); // duplicates are ignored assertThat(abc).containsOnly("a", "a", "b", "c", "c"); // ... on both actual and expected values assertThat(new String[] { "a", "a", "b" }).containsOnly("a", "b") .containsOnly("a", "a", "b", "b"); // assertion will fail because the given values do not contain "c" assertThat(abc).containsOnly("a", "b"); // assertion will fail because abc does not contain "d" assertThat(abc).containsOnly("a", "b", "c", "d");
- Specified by:
containsOnly
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
containsOnly
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
values
- the given values.- Returns:
this
assertion object.
-
containsOnlyOnce
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array contains the given values only once.Examples :
// array is a factory method to create arrays. // assertions will pass assertThat(array("winter", "is", "coming")).containsOnlyOnce("winter"); assertThat(array("winter", "is", "coming")).containsOnlyOnce("coming", "winter"); // assertions will fail assertThat(array("winter", "is", "coming")).containsOnlyOnce("Lannister"); assertThat(array("Arya", "Stark", "daughter", "of", "Ned", "Stark")).containsOnlyOnce("Stark"); assertThat(array("Arya", "Stark", "daughter", "of", "Ned", "Stark")).containsOnlyOnce("Stark", "Lannister", "Arya");
- Specified by:
containsOnlyOnce
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
containsOnlyOnce
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
values
- the given values.- Returns:
this
assertion object.
-
containsExactly
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array contains exactly the given values and nothing else, in order.
Example :
Ring[] elvesRings = {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);
- Specified by:
containsExactly
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
containsExactly
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
values
- the given values.- Returns:
this
assertion object.
-
containsExactlyInAnyOrder
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array contains exactly the given values and nothing else, in any order.
Example :
Ring[] elvesRings = {vilya, nenya, narya, vilya}; // assertion will pass assertThat(elvesRings).containsExactlyInAnyOrder(vilya, vilya, nenya, narya); // assertion will fail as vilya exists twice in elvesRings assertThat(elvesRings).containsExactlyInAnyOrder(nenya, vilya, narya);
- Specified by:
containsExactlyInAnyOrder
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
containsExactlyInAnyOrder
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
values
- the given values.- Returns:
this
assertion object.
-
containsAnyOf
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array contains at least one of the given values.Example :
String[] abc = {"a", "b", "c"}; // assertions will pass assertThat(abc).containsAnyOf("b") .containsAnyOf("b", "c") .containsAnyOf("a", "b", "c") .containsAnyOf("a", "b", "c", "d") .containsAnyOf("e", "f", "g", "b"); // assertions will fail assertThat(abc).containsAnyOf("d"); assertThat(abc).containsAnyOf("d", "e", "f", "g");
- Specified by:
containsAnyOf
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
containsAnyOf
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
values
- the values whose at least one which is expected to be in the array under test.- Returns:
this
assertion object.
-
isSubsetOf
Description copied from class:AbstractObjectArrayAssert
Verifies that all elements of actual are present in the given values.Example:
Ring[] elvesRings = {vilya, nenya, narya}; // assertions will pass: assertThat(elvesRings).isSubsetOf(vilya, nenya, narya); assertThat(elvesRings).isSubsetOf(vilya, nenya, narya, dwarfRing); // assertions will fail: assertThat(elvesRings).isSubsetOf(vilya, nenya); assertThat(elvesRings).isSubsetOf(vilya, nenya, dwarfRing);
- Specified by:
isSubsetOf
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
isSubsetOf
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
values
- the values that should be used for checking the elements of actual.- Returns:
- this assertion object.
-
containsSequence
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array contains the given sequence in the correct order and without extra values between the sequence values.Use
AbstractObjectArrayAssert.containsSubsequence(Object...)
to allow values between the expected sequence values.Example:
Ring[] elvesRings = {vilya, nenya, narya}; // assertion will pass assertThat(elvesRings).containsSequence(vilya, nenya); assertThat(elvesRings).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);
- Specified by:
containsSequence
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
containsSequence
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
-
doesNotContainSequence
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array does not contain the given sequence in the given order and without extra values between the sequence values.Use
AbstractObjectArrayAssert.doesNotContainSubsequence(Object...)
to also ensure the sequence does not exist with values between the expected sequence values.Example:
Ring[] elvesRings = {vilya, nenya, narya}; // assertion will pass, the elements order is correct but there is a value between them (nenya) assertThat(elvesRings).containsSequence(vilya, narya); assertThat(elvesRings).containsSequence(nenya, vilya); // assertions will fail assertThat(elvesRings).containsSequence(vilya, nenya); assertThat(elvesRings).containsSequence(nenya, narya);
- Specified by:
doesNotContainSequence
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
doesNotContainSequence
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
sequence
- the sequence of objects to look for.- Returns:
- this assertion object.
-
containsSubsequence
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array contains the given subsequence in the correct order (possibly with other values between them).Example:
Ring[] elvesRings = {vilya, nenya, narya}; // assertions will pass assertThat(elvesRings).containsSubsequence(vilya, nenya); assertThat(elvesRings).containsSubsequence(vilya, narya); // assertion will fail assertThat(elvesRings).containsSubsequence(nenya, vilya);
- Specified by:
containsSubsequence
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
containsSubsequence
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
sequence
- the subsequence of objects to look for.- Returns:
- this assertion object.
-
doesNotContainSubsequence
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array does not contain the given subsequence in the correct order (possibly with other values between them).Example:
Ring[] elvesRings = {vilya, nenya, narya}; // assertions will pass assertThat(elvesRings).doesNotContainSubsequence(nenya, vilya); // assertion will fail assertThat(elvesRings).doesNotContainSubsequence(vilya, nenya); assertThat(elvesRings).doesNotContainSubsequence(vilya, narya);
- Specified by:
doesNotContainSubsequence
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
doesNotContainSubsequence
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
sequence
- the subsequence of objects to look for.- Returns:
- this assertion object.
-
doesNotContain
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array does not contain the given values.Example :
String[] abc = {"a", "b", "c"}; // assertion will pass assertThat(abc).doesNotContain("d", "e"); // assertions will fail assertThat(abc).doesNotContain("a"); assertThat(abc).doesNotContain("a", "b", "c"); assertThat(abc).doesNotContain("a", "x");
- Specified by:
doesNotContain
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
doesNotContain
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
values
- the given values.- Returns:
this
assertion object.
-
endsWith
Description copied from class:AbstractObjectArrayAssert
Verifies that the actual array 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 array.AbstractObjectArrayAssert.containsSequence(Object...)
Example :
String[] abc = {"a", "b", "c"}; // assertion will pass assertThat(abc).endsWith("b", "c"); // assertion will fail assertThat(abc).endsWith("a");
- Specified by:
endsWith
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
endsWith
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
first
- the first element of the end sequence of objects to look for.rest
- the rest of the end sequence of objects to look for.- Returns:
- this assertion object.
-
satisfiesExactly
@SafeVarargs public final ObjectArrayAssert<ELEMENT> satisfiesExactly(Consumer<? super ELEMENT>... requirements) Description copied from interface:ObjectEnumerableAssert
Verifies that each element satisfies the requirements corresponding to its index, so the first element must satisfy the first requirements, the second element the second requirements etc...Each requirements are expressed as a
Consumer
, there must be as many requirements as there are iterable elements.Example:
Iterable<TolkienCharater> characters = list(frodo, aragorn, legolas); // assertions succeed assertThat(characters).satisfiesExactly(character -> assertThat(character.getRace()).isEqualTo("Hobbit"), character -> assertThat(character.isMortal()).isTrue(), character -> assertThat(character.getName()).isEqualTo("Legolas")); // you can specify more that one assertion per requirements assertThat(characters).satisfiesExactly(character -> { assertThat(character.getRace()).isEqualTo("Hobbit"); assertThat(character.getName()).isEqualTo("Frodo"); }, character -> { assertThat(character.isMortal()).isTrue(); assertThat(character.getName()).isEqualTo("Aragorn"); }, character -> { assertThat(character.getRace()).isEqualTo("Elf"); assertThat(character.getName()).isEqualTo("Legolas"); }); // assertion fails as aragorn does not meet the second requirements assertThat(characters).satisfiesExactly(character -> assertThat(character.getRace()).isEqualTo("Hobbit"), character -> assertThat(character.isMortal()).isFalse(), character -> assertThat(character.getName()).isEqualTo("Legolas"));
- Specified by:
satisfiesExactly
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
satisfiesExactly
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
requirements
- the requirements to meet.- Returns:
this
to chain assertions.
-
satisfiesExactlyInAnyOrder
@SafeVarargs public final ObjectArrayAssert<ELEMENT> satisfiesExactlyInAnyOrder(Consumer<? super ELEMENT>... requirements) Description copied from interface:ObjectEnumerableAssert
Verifies that at least one combination of iterable elements exists that satisfies the consumers in order (there must be as many consumers as iterable elements and once a consumer is matched it cannot be reused to match other elements).This is a variation of
ObjectEnumerableAssert.satisfiesExactly(Consumer...)
where order does not matter.Examples:
List<String> starWarsCharacterNames = list("Luke", "Leia", "Yoda"); // these assertions succeed: assertThat(starWarsCharacterNames).satisfiesExactlyInAnyOrder(name -> assertThat(name).contains("Y"), // matches "Yoda" name -> assertThat(name).contains("L"), // matches "Luke" and "Leia" name -> { assertThat(name).hasSize(4); assertThat(name).doesNotContain("a"); // matches "Luke" but not "Leia" }) .satisfiesExactlyInAnyOrder(name -> assertThat(name).contains("Yo"), name -> assertThat(name).contains("Lu"), name -> assertThat(name).contains("Le")) .satisfiesExactlyInAnyOrder(name -> assertThat(name).contains("Le"), name -> assertThat(name).contains("Yo"), name -> assertThat(name).contains("Lu")); // this assertion fails as 3 consumer/requirements are expected assertThat(starWarsCharacterNames).satisfiesExactlyInAnyOrder(name -> assertThat(name).contains("Y"), name -> assertThat(name).contains("L")); // this assertion fails as no element contains "Han" (first consumer/requirements can't be met) assertThat(starWarsCharacterNames).satisfiesExactlyInAnyOrder(name -> assertThat(name).contains("Han"), name -> assertThat(name).contains("L"), name -> assertThat(name).contains("Y")); // this assertion fails as "Yoda" element can't satisfy any consumers/requirements (even though all consumers/requirements are met) assertThat(starWarsCharacterNames).satisfiesExactlyInAnyOrder(name -> assertThat(name).contains("L"), name -> assertThat(name).contains("L"), name -> assertThat(name).contains("L")); // this assertion fails as no combination of elements can satisfy the consumers in order // the problem is if the last consumer is matched by Leia then no other consumer can match Luke (and vice versa) assertThat(starWarsCharacterNames).satisfiesExactlyInAnyOrder(name -> assertThat(name).contains("Y"), name -> assertThat(name).contains("o"), name -> assertThat(name).contains("L"));
- Specified by:
satisfiesExactlyInAnyOrder
in interfaceObjectEnumerableAssert<AbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT>, ELEMENT> - Overrides:
satisfiesExactlyInAnyOrder
in classAbstractObjectArrayAssert<ObjectArrayAssert<ELEMENT>,
ELEMENT> - Parameters:
requirements
- the consumers that are expected to be satisfied by the elements of the givenIterable
.- Returns:
- this assertion object.
-