Uses of Class
org.assertj.core.api.AtomicReferenceArrayAssert
-
Uses of AtomicReferenceArrayAssert in org.assertj.core.api
Modifier and TypeMethodDescriptionVerifies that all elements match the givenPredicate
.Verifies that all the elements of actual's array match the givenPredicate
.AtomicReferenceArrayAssert.allSatisfy
(Consumer<? super T> requirements) Verifies that all the elements satisfy given requirements expressed as aConsumer
.AtomicReferenceArrayAssert.allSatisfy
(ThrowingConsumer<? super T> requirements) Verifies that all the elements satisfy the given requirements expressed as aThrowingConsumer
.Verifies whether any elements match the providedPredicate
.AtomicReferenceArrayAssert.anySatisfy
(Consumer<? super T> requirements) Verifies that at least one element satisfies the given requirements expressed as aConsumer
.AtomicReferenceArrayAssert.anySatisfy
(ThrowingConsumer<? super T> requirements) Verifies that at least one element satisfies the given requirements expressed as aThrowingConsumer
.Verifies that each element value satisfies the given conditionAtomicReferenceArrayAssert.areAtLeast
(int times, Condition<? super T> condition) Verifies that there are at least n elements in the actual AtomicReferenceArray satisfying the given condition.AtomicReferenceArrayAssert.areAtLeastOne
(Condition<? super T> condition) Verifies that there is at least one element in the actual AtomicReferenceArray satisfying the given condition.Verifies that there are at most n elements in the actual AtomicReferenceArray satisfying the given condition.AtomicReferenceArrayAssert.areExactly
(int times, Condition<? super T> condition) Verifies that there are exactly n elements in the actual AtomicReferenceArray satisfying the given condition.Verifies that each element value does not satisfy the given conditionAtomicReferenceArrayAssert.as
(Description description) static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Assertions.assertThat
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6Assertions.assertThat
(AtomicReferenceArray<ELEMENT> actual) Deprecated.Create assertion forAtomicReferenceArray
.default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6StandardSoftAssertionsProvider.assertThat
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
WithAssertions.assertThat
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Assumptions.assumeThat
(AtomicReferenceArray<ELEMENT> actual) Create assumption forAtomicReferenceArray
.default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
WithAssumptions.assumeThat
(AtomicReferenceArray<ELEMENT> actual) Creates a new instance of
assumption.AtomicReferenceArrayAssert
final AtomicReferenceArrayAssert<T>
Verifies that the actual AtomicReferenceArray contains the given values, in any order.Verifies that the actual AtomicReferenceArray contains the given object at the given index.AtomicReferenceArrayAssert.containsAll
(Iterable<? extends T> iterable) Verifies that the actual AtomicReferenceArray contains all the elements of givenIterable
, in any order.AtomicReferenceArrayAssert.containsAnyElementsOf
(Iterable<? extends T> iterable) Verifies that the actual AtomicReferenceArray contains at least one of the givenIterable
elements.final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsAnyOf
(T... values) Verifies that the actual AtomicReferenceArray contains at least one of the given values.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsAnyOfForProxy
(T[] values) final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsExactly
(T... values) Verifies that the actual AtomicReferenceArray contains only the given values and nothing else, in order.AtomicReferenceArrayAssert.containsExactlyElementsOf
(Iterable<? extends T> iterable) Same ascontainsExactly(Object...)
but handles theIterable
to array conversion : verifies that actual contains all elements of the givenIterable
and nothing else in the same order.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsExactlyForProxy
(T[] values) final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsExactlyInAnyOrder
(T... values) Verifies that the actual AtomicReferenceArray contains exactly the given values and nothing else, in any order.AtomicReferenceArrayAssert.containsExactlyInAnyOrderElementsOf
(Iterable<? extends T> values) Verifies that the actual AtomicReferenceArray contains exactly the given values and nothing else, in any order.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsExactlyInAnyOrderForProxy
(T[] values) protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsForProxy
(T[] values) AtomicReferenceArrayAssert.containsNull()
Verifies that the actual AtomicReferenceArray contains at least a null element.final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsOnly
(T... values) Verifies that the actual AtomicReferenceArray contains only the given values and nothing else, in any order and ignoring duplicates (i.e.AtomicReferenceArrayAssert.containsOnlyElementsOf
(Iterable<? extends T> iterable) Same semantic ascontainsOnly(Object[])
: verifies that actual contains all elements of the givenIterable
and nothing else, in any order and ignoring duplicates (i.e.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsOnlyForProxy
(T[] values) AtomicReferenceArrayAssert.containsOnlyNulls()
Verifies that the actual AtomicReferenceArray contains only null elements and nothing else.final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsOnlyOnce
(T... values) Verifies that the actual AtomicReferenceArray contains the given values only once.AtomicReferenceArrayAssert.containsOnlyOnceElementsOf
(Iterable<? extends T> iterable) Same semantic asObjectEnumerableAssert.containsOnlyOnce(Object...)
: verifies that the actual group contains the elements of the given iterable only once.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsOnlyOnceForProxy
(T[] values) AtomicReferenceArrayAssert.containsSequence
(Iterable<? extends T> sequence) Verifies that the actual AtomicReferenceArray contains the given sequence in the correct order and without extra values between the sequence values.final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsSequence
(T... sequence) Verifies that the actual AtomicReferenceArray contains the given sequence in the correct order and without extra values between the sequence values.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsSequenceForProxy
(T[] sequence) AtomicReferenceArrayAssert.containsSubsequence
(Iterable<? extends T> subsequence) Verifies that the actual AtomicReferenceArray contains the given subsequence in the correct order (possibly with other values between them).final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsSubsequence
(T... subsequence) Verifies that the actual AtomicReferenceArray contains the given subsequence in the correct order (possibly with other values between them).protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.containsSubsequenceForProxy
(T[] subsequence) final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.doesNotContain
(T... values) Verifies that the actual AtomicReferenceArray does not contain the given values.AtomicReferenceArrayAssert.doesNotContain
(T value, Index index) Verifies that the actual AtomicReferenceArray does not contain the given object at the given index.AtomicReferenceArrayAssert.doesNotContainAnyElementsOf
(Iterable<? extends T> iterable) Verifies that the actual AtomicReferenceArray does not contain any elements of the givenIterable
(i.e.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.doesNotContainForProxy
(T[] values) AtomicReferenceArrayAssert.doesNotContainNull()
Verifies that the actual AtomicReferenceArray does not contain null elements.AtomicReferenceArrayAssert.doesNotContainSequence
(Iterable<? extends T> sequence) Verifies that the actual AtomicReferenceArray contains the given sequence in the given order and without extra values between the sequence values.final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.doesNotContainSequence
(T... sequence) Verifies that the actual AtomicReferenceArray contains the given sequence in the given order and without extra values between the sequence values.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.doesNotContainSequenceForProxy
(T[] sequence) AtomicReferenceArrayAssert.doesNotContainSubsequence
(Iterable<? extends T> subsequence) Verifies that the actual AtomicReferenceArray does not contain the given subsequence in the correct order (possibly with other values between them).final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.doesNotContainSubsequence
(T... subsequence) Verifies that the actual AtomicReferenceArray does not contain the given subsequence in the correct order (possibly with other values between them).protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.doesNotContainSubsequenceForProxy
(T[] subsequence) AtomicReferenceArrayAssert.doesNotHaveAnyElementsOfTypes
(Class<?>... unexpectedTypes) Verifies that all the elements in the actual AtomicReferenceArray do not belong to the specified types (including subclasses).AtomicReferenceArrayAssert.doesNotHaveDuplicates()
Verifies that the actual AtomicReferenceArray does not contain duplicates.Verifies that all elements don't satisfy the given condition.Verifies that the actual AtomicReferenceArray ends with the given sequence of objects, without any other objects between them.final AtomicReferenceArrayAssert<T>
Verifies that the actual AtomicReferenceArray ends with the given sequence of objects, without any other objects between them.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.endsWithForProxy
(T first, T[] sequence) AtomicReferenceArrayAssert.filteredOn
(String propertyOrFieldName, Object expectedValue) Filter the array under test keeping only elements having a property or field equal toexpectedValue
, the property/field is specified bypropertyOrFieldName
parameter.AtomicReferenceArrayAssert.filteredOn
(String propertyOrFieldName, FilterOperator<?> filterOperator) Filter the array under test keeping only elements having a property or field matching the filter expressed with theFilterOperator
, the property/field is specified bypropertyOrFieldName
parameter.AtomicReferenceArrayAssert.filteredOn
(Function<? super T, U> function, U expectedValue) Filter the array under test into a list composed of the elements for which the result of thefunction
is equal toexpectedValue
.AtomicReferenceArrayAssert.filteredOn
(Predicate<? super T> predicate) Filter the array under test into a list composed of the elements matching the givenPredicate
, allowing to perform assertions on the filtered list.AtomicReferenceArrayAssert.filteredOn
(Condition<? super T> condition) Filter the array under test keeping only elements matching the givenCondition
.AtomicReferenceArrayAssert.filteredOnNull
(String propertyOrFieldName) Filter the array under test keeping only elements whose property or field specified bypropertyOrFieldName
is null.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
BDDAssumptions.given
(AtomicReferenceArray<ELEMENT> actual) Creates a new assumption's instance for anAtomicReferenceArray
value.Verifies that the AtomicReferenceArray has the given array.AtomicReferenceArrayAssert.hasAtLeastOneElementOfType
(Class<?> expectedType) Verifies that at least one element in the actual AtomicReferenceArray has the specified type (matching includes subclasses of the given type).AtomicReferenceArrayAssert.hasExactlyElementsOfTypes
(Class<?>... expectedTypes) Verifies that the actual elements are of the given types in the given order, there should be as many expected types as there are actual elements.AtomicReferenceArrayAssert.hasOnlyElementsOfType
(Class<?> expectedType) Verifies that all the elements in the actual AtomicReferenceArray belong to the specified type (matching includes subclasses of the given type).AtomicReferenceArrayAssert.hasOnlyElementsOfTypes
(Class<?>... types) Verifies that all elements of the actual group are instances of given classes or interfaces.AtomicReferenceArrayAssert.hasOnlyOneElementSatisfying
(Consumer<? super T> elementAssertions) Verifies that the unique element of theAtomicReferenceArray
satisfies the given assertions expressed as aConsumer
, if it does not, only the first error is reported, useSoftAssertions
to get all the errors.AtomicReferenceArrayAssert.hasSameElementsAs
(Iterable<? extends T> iterable) An alias ofcontainsOnlyElementsOf(Iterable)
: verifies that actual contains all elements of the givenIterable
and nothing else, in any order.AtomicReferenceArrayAssert.hasSameSizeAs
(Iterable<?> other) Verifies that the actual AtomicReferenceArray has the same size as the givenIterable
.AtomicReferenceArrayAssert.hasSameSizeAs
(Object other) Verifies that the actual AtomicReferenceArray has the same size as the given array.AtomicReferenceArrayAssert.hasSize
(int expected) Verifies that the number of values in the AtomicReferenceArray is equal to the given one.AtomicReferenceArrayAssert.hasSizeBetween
(int lowerBoundary, int higherBoundary) Verifies that the number of values in the actual array is between the given boundaries (inclusive).AtomicReferenceArrayAssert.hasSizeGreaterThan
(int boundary) Verifies that the number of values in the actual array is greater than the given boundary.AtomicReferenceArrayAssert.hasSizeGreaterThanOrEqualTo
(int boundary) Verifies that the number of values in the actual array is greater than or equal to the given boundary.AtomicReferenceArrayAssert.hasSizeLessThan
(int boundary) Verifies that the number of values in the actual array is less than the given boundary.AtomicReferenceArrayAssert.hasSizeLessThanOrEqualTo
(int boundary) Verifies that the number of values in the actual array is less than or equal to the given boundary.Verifies that all elements satisfy the given condition.AtomicReferenceArrayAssert.haveAtLeast
(int times, Condition<? super T> condition) Verifies that there are at least n elements in the actual AtomicReferenceArray satisfying the given condition.AtomicReferenceArrayAssert.haveAtLeastOne
(Condition<? super T> condition) Verifies that there is at least one element in the actual AtomicReferenceArray satisfying the given condition.AtomicReferenceArrayAssert.haveAtMost
(int times, Condition<? super T> condition) Verifies that there are at most n elements in the actual AtomicReferenceArray satisfying the given condition.AtomicReferenceArrayAssert.haveExactly
(int times, Condition<? super T> condition) Verifies that there are exactly n elements in the actual AtomicReferenceArray satisfying the given condition.AtomicReferenceArrayAssert.inBinary()
AtomicReferenceArrayAssert.inHexadecimal()
Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.AtomicReferenceArrayAssert.isNotEmpty()
Verifies that the AtomicReferenceArray is not empty.AtomicReferenceArrayAssert.isSorted()
Verifies that the actual array is sorted in ascending order according to the natural ordering of its elements.AtomicReferenceArrayAssert.isSortedAccordingTo
(Comparator<? super T> comparator) Verifies that the actual array is sorted according to the given comparator.
Empty arrays are considered sorted whatever the comparator is.
One element arrays are considered sorted if the element is compatible with comparator, otherwise an AssertionError is thrown.AtomicReferenceArrayAssert.isSubsetOf
(Iterable<? extends T> values) Verifies that all elements of actual are present in the givenIterable
.final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.isSubsetOf
(T... values) Verifies that all elements of actual are present in the given values.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.isSubsetOfForProxy
(T[] values) Verifies that no elements match the givenPredicate
.AtomicReferenceArrayAssert.noneSatisfy
(Consumer<? super T> restrictions) Verifies that no elements satisfy the given restrictions expressed as aConsumer
.AtomicReferenceArrayAssert.noneSatisfy
(ThrowingConsumer<? super T> restrictions) Verifies that no elements satisfy the given restrictions expressed as aConsumer
.final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.satisfiesExactly
(Consumer<? super T>... 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 AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.satisfiesExactly
(ThrowingConsumer<? super T>... 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...protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.satisfiesExactlyForProxy
(Consumer<? super T>[] requirements) final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.satisfiesExactlyInAnyOrder
(Consumer<? super T>... 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).final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.satisfiesExactlyInAnyOrder
(ThrowingConsumer<? super T>... requirements) Verifies that at least one combination of iterable elements exists that satisfies theThrowingConsumer
s 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).protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.satisfiesExactlyInAnyOrderForProxy
(Consumer<? super T>[] requirements) final AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.startsWith
(T... sequence) Verifies that the actual AtomicReferenceArray starts with the given sequence of objects, without any other objects between them.protected AtomicReferenceArrayAssert<T>
AtomicReferenceArrayAssert.startsWithForProxy
(T[] sequence) static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
BDDAssertions.then
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6BDDAssertions.then
(AtomicReferenceArray<ELEMENT> actual) Deprecated.Create assertion forAtomicReferenceArray
.default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6BDDSoftAssertionsProvider.then
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.AtomicReferenceArrayAssert.usingComparatorForElementFieldsWithNames
(Comparator<C> comparator, String... elementPropertyOrFieldNames) Deprecated.AtomicReferenceArrayAssert.usingComparatorForElementFieldsWithType
(Comparator<C> comparator, Class<C> type) Deprecated.This method is used withusingFieldByFieldElementComparator()
which is deprecated in favor ofusingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)
orAbstractAssert.usingRecursiveComparison()
.AtomicReferenceArrayAssert.usingComparatorForType
(Comparator<C> comparator, Class<C> type) Allows to set a specific comparator for the given type of elements or their fields.AtomicReferenceArrayAssert.usingDefaultElementComparator()
Revert to standard comparison for incoming assertion group element checks.AtomicReferenceArrayAssert.usingElementComparator
(Comparator<? super T> elementComparator) Use given custom comparator instead of relying on actual element typeequals
method to compare AtomicReferenceArray elements for incoming assertion checks.AtomicReferenceArrayAssert.usingElementComparatorIgnoringFields
(String... fields) Deprecated.This method is deprecated because it performs a shallow field by field comparison, i.e.AtomicReferenceArrayAssert.usingElementComparatorOnFields
(String... fields) Deprecated.This method is deprecated because it performs a shallow field by field comparison, i.e.AtomicReferenceArrayAssert.usingFieldByFieldElementComparator()
Deprecated.This method is deprecated because it performs a shallow field by field comparison, i.e.AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparator()
Enable using a recursive field by field comparison strategy similar toAbstractAssert.usingRecursiveComparison()
but contrary to the latter you can chain any iterable assertions after this method (this is why this method exists).AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparator
(RecursiveComparisonConfiguration configuration) Enable using a recursive field by field comparison strategy similar toAbstractAssert.usingRecursiveComparison()
but contrary to the latter you can chain any iterable assertions after this method (this is why this method exists).AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields
(String... fields) The assertions chained after this method will use a recursive field by field comparison on all fields (including inherited fields) except the given ones instead of relying on the elementequals
method.AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparatorOnFields
(String... fields) The assertions chained after this method will use a recursive field by field comparison on the given fields (including inherited fields) instead of relying on the elementequals
method.Modifier and TypeMethodDescriptionstatic <ELEMENT> InstanceOfAssertFactory<AtomicReferenceArray,
AtomicReferenceArrayAssert<ELEMENT>> InstanceOfAssertFactories.atomicReferenceArray
(Class<ELEMENT> elementType)
usingFieldByFieldElementComparator()
which is deprecated in favor ofusingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)
orAbstractAssert.usingRecursiveComparison()
.