Uses of Class
org.assertj.core.api.AtomicReferenceArrayAssert

Packages that use AtomicReferenceArrayAssert

Package	Description
org.assertj.core.api

Uses of AtomicReferenceArrayAssert in org.assertj.core.api

Fields in org.assertj.core.api with type parameters of type AtomicReferenceArrayAssert

Modifier and Type	Field and Description
static InstanceOfAssertFactory<AtomicReferenceArray,AtomicReferenceArrayAssert<Object>>	InstanceOfAssertFactories.ATOMIC_REFERENCE_ARRAY InstanceOfAssertFactory for an AtomicReferenceArray, assuming Object as element type.

Methods in org.assertj.core.api that return AtomicReferenceArrayAssert

Modifier and Type	Method and Description
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.allMatch(Predicate<? super T> predicate) Verifies that all elements match the given Predicate.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.allMatch(Predicate<? super T> predicate, String predicateDescription) Verifies that all the elements of actual's array match the given Predicate.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.allSatisfy(Consumer<? super T> requirements) Verifies that all the elements satisfy given requirements expressed as a Consumer.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.allSatisfy(ThrowingConsumer<? super T> requirements) Verifies that all the elements satisfy the given requirements expressed as a ThrowingConsumer.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.anyMatch(Predicate<? super T> predicate) Verifies whether any elements match the provided Predicate.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.anySatisfy(Consumer<? super T> requirements) Verifies that at least one element satisfies the given requirements expressed as a Consumer.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.anySatisfy(ThrowingConsumer<? super T> requirements) Verifies that at least one element satisfies the given requirements expressed as a ThrowingConsumer.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.are(Condition<? super T> condition) Verifies that each element value satisfies the given condition
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.areAtLeast(int times, Condition<? super T> condition) Verifies that there are at least n elements in the actual AtomicReferenceArray satisfying the given condition.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.areAtLeastOne(Condition<? super T> condition) Verifies that there is at least one element in the actual AtomicReferenceArray satisfying the given condition.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.areAtMost(int times, Condition<? super T> condition) Verifies that there are at most n elements in the actual AtomicReferenceArray satisfying the given condition.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.areExactly(int times, Condition<? super T> condition) Verifies that there are exactly n elements in the actual AtomicReferenceArray satisfying the given condition.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.areNot(Condition<? super T> condition) Verifies that each element value does not satisfy the given condition
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.as(Description description)
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.as(String description, Object... args)
default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	WithAssertions.assertThat(AtomicReferenceArray<ELEMENT> actual) Create assertion for AtomicReferenceArray.
default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Java6StandardSoftAssertionsProvider.assertThat(AtomicReferenceArray<ELEMENT> actual) Create assertion for AtomicReferenceArray.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Java6Assertions.assertThat(AtomicReferenceArray<ELEMENT> actual) Deprecated. Create assertion for AtomicReferenceArray.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Assertions.assertThat(AtomicReferenceArray<ELEMENT> actual) Create assertion for AtomicReferenceArray.
default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	WithAssumptions.assumeThat(AtomicReferenceArray<ELEMENT> actual) Creates a new instance of AtomicReferenceArrayAssert assumption.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Assumptions.assumeThat(AtomicReferenceArray<ELEMENT> actual) Create assumption for AtomicReferenceArray.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.contains(T... values) Verifies that the actual AtomicReferenceArray contains the given values, in any order.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.contains(T value, Index index) Verifies that the actual AtomicReferenceArray contains the given object at the given index.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsAll(Iterable<? extends T> iterable) Verifies that the actual AtomicReferenceArray contains all the elements of given Iterable, in any order.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsAnyElementsOf(Iterable<? extends T> iterable) Verifies that the actual AtomicReferenceArray contains at least one of the given Iterable elements.
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)
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsExactly(T... values) Verifies that the actual AtomicReferenceArray contains only the given values and nothing else, in order.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsExactlyElementsOf(Iterable<? extends T> iterable) Same as containsExactly(Object...) but handles the Iterable to array conversion : verifies that actual contains all elements of the given Iterable and nothing else in the same order.
protected AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsExactlyForProxy(T[] values)
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsExactlyInAnyOrder(T... values) Verifies that the actual AtomicReferenceArray contains exactly the given values and nothing else, in any order.
AtomicReferenceArrayAssert<T>	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<T>	AtomicReferenceArrayAssert.containsNull() Verifies that the actual AtomicReferenceArray contains at least a null element.
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<T>	AtomicReferenceArrayAssert.containsOnlyElementsOf(Iterable<? extends T> iterable) Same semantic as containsOnly(Object[]) : verifies that actual contains all elements of the given Iterable and nothing else, in any order and ignoring duplicates (i.e.
protected AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsOnlyForProxy(T[] values)
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsOnlyNulls() Verifies that the actual AtomicReferenceArray contains only null elements and nothing else.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsOnlyOnce(T... values) Verifies that the actual AtomicReferenceArray contains the given values only once.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsOnlyOnceElementsOf(Iterable<? extends T> iterable) Same semantic as ObjectEnumerableAssert.containsOnlyOnce(Object...) : verifies that the actual group contains the elements of the given iterable only once.
protected AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.containsOnlyOnceForProxy(T[] values)
AtomicReferenceArrayAssert<T>	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.
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<T>	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).
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)
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.doesNotContain(T... values) Verifies that the actual AtomicReferenceArray does not contain the given values.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.doesNotContain(T value, Index index) Verifies that the actual AtomicReferenceArray does not contain the given object at the given index.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.doesNotContainAnyElementsOf(Iterable<? extends T> iterable) Verifies that the actual AtomicReferenceArray does not contain any elements of the given Iterable (i.e.
protected AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.doesNotContainForProxy(T[] values)
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.doesNotContainNull() Verifies that the actual AtomicReferenceArray does not contain null elements.
AtomicReferenceArrayAssert<T>	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.
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<T>	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).
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<T>	AtomicReferenceArrayAssert.doesNotHaveAnyElementsOfTypes(Class<?>... unexpectedTypes) Verifies that all the elements in the actual AtomicReferenceArray do not belong to the specified types (including subclasses).
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.doesNotHaveDuplicates() Verifies that the actual AtomicReferenceArray does not contain duplicates.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.doNotHave(Condition<? super T> condition) Verifies that all elements don't satisfy the given condition.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.endsWith(T[] sequence) Verifies that the actual AtomicReferenceArray ends with the given sequence of objects, without any other objects between them.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.endsWith(T first, T... sequence) 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<T>	AtomicReferenceArrayAssert.filteredOn(Condition<? super T> condition) Filter the array under test keeping only elements matching the given Condition.
<U> AtomicReferenceArrayAssert<T>	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 the function is equal to expectedValue.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.filteredOn(Predicate<? super T> predicate) Filter the array under test into a list composed of the elements matching the given Predicate, allowing to perform assertions on the filtered list.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.filteredOn(String propertyOrFieldName, FilterOperator<?> filterOperator) Filter the array under test keeping only elements having a property or field matching the filter expressed with the FilterOperator, the property/field is specified by propertyOrFieldName parameter.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.filteredOn(String propertyOrFieldName, Object expectedValue) Filter the array under test keeping only elements having a property or field equal to expectedValue, the property/field is specified by propertyOrFieldName parameter.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.filteredOnNull(String propertyOrFieldName) Filter the array under test keeping only elements whose property or field specified by propertyOrFieldName is null.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	BDDAssumptions.given(AtomicReferenceArray<ELEMENT> actual) Creates a new assumption's instance for an AtomicReferenceArray value.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasArray(T[] expected) Verifies that the AtomicReferenceArray has the given array.
AtomicReferenceArrayAssert<T>	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<T>	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<T>	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<T>	AtomicReferenceArrayAssert.hasOnlyElementsOfTypes(Class<?>... types) Verifies that all elements of the actual group are instances of given classes or interfaces.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasOnlyOneElementSatisfying(Consumer<? super T> elementAssertions) Verifies that the unique element of the AtomicReferenceArray satisfies the given assertions expressed as a Consumer, if it does not, only the first error is reported, use SoftAssertions to get all the errors.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasSameElementsAs(Iterable<? extends T> iterable) An alias of containsOnlyElementsOf(Iterable) : verifies that actual contains all elements of the given Iterable and nothing else, in any order.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasSameSizeAs(Iterable<?> other) Verifies that the actual AtomicReferenceArray has the same size as the given Iterable.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasSameSizeAs(Object other) Verifies that the actual AtomicReferenceArray has the same size as the given array.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasSize(int expected) Verifies that the number of values in the AtomicReferenceArray is equal to the given one.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasSizeBetween(int lowerBoundary, int higherBoundary) Verifies that the number of values in the actual array is between the given boundaries (inclusive).
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasSizeGreaterThan(int boundary) Verifies that the number of values in the actual array is greater than the given boundary.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasSizeGreaterThanOrEqualTo(int boundary) Verifies that the number of values in the actual array is greater than or equal to the given boundary.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasSizeLessThan(int boundary) Verifies that the number of values in the actual array is less than the given boundary.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.hasSizeLessThanOrEqualTo(int boundary) Verifies that the number of values in the actual array is less than or equal to the given boundary.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.have(Condition<? super T> condition) Verifies that all elements satisfy the given condition.
AtomicReferenceArrayAssert<T>	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<T>	AtomicReferenceArrayAssert.haveAtLeastOne(Condition<? super T> condition) Verifies that there is at least one element in the actual AtomicReferenceArray satisfying the given condition.
AtomicReferenceArrayAssert<T>	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<T>	AtomicReferenceArrayAssert.haveExactly(int times, Condition<? super T> condition) Verifies that there are exactly n elements in the actual AtomicReferenceArray satisfying the given condition.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.inBinary()
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.inHexadecimal() Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.isNotEmpty() Verifies that the AtomicReferenceArray is not empty.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.isSorted() Verifies that the actual array is sorted in ascending order according to the natural ordering of its elements.
AtomicReferenceArrayAssert<T>	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<T>	AtomicReferenceArrayAssert.isSubsetOf(Iterable<? extends T> values) Verifies that all elements of actual are present in the given Iterable.
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)
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.noneMatch(Predicate<? super T> predicate) Verifies that no elements match the given Predicate.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.noneSatisfy(Consumer<? super T> restrictions) Verifies that no elements satisfy the given restrictions expressed as a Consumer.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.noneSatisfy(ThrowingConsumer<? super T> restrictions) Verifies that no elements satisfy the given restrictions expressed as a Consumer.
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...
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)
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).
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.satisfiesExactlyInAnyOrder(ThrowingConsumer<? super T>... requirements) Verifies that at least one combination of iterable elements exists that satisfies the ThrowingConsumers 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)
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)
default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Java6BDDSoftAssertionsProvider.then(AtomicReferenceArray<ELEMENT> actual) Create assertion for AtomicReferenceArray.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	Java6BDDAssertions.then(AtomicReferenceArray<ELEMENT> actual) Deprecated. Create assertion for AtomicReferenceArray.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	BDDAssertions.then(AtomicReferenceArray<ELEMENT> actual) Create assertion for AtomicReferenceArray.
<C> AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingComparatorForElementFieldsWithNames(Comparator<C> comparator, String... elementPropertyOrFieldNames) Deprecated. This method is used with usingFieldByFieldElementComparator() which is deprecated in favor of usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration) or AbstractAssert.usingRecursiveComparison(). When using AbstractAssert.usingRecursiveComparison() the equivalent is: RecursiveComparisonAssert.withEqualsForFields(java.util.function.BiPredicate, String...) RecursiveComparisonAssert.withComparatorForFields(Comparator, String...) and when using RecursiveComparisonConfiguration: RecursiveComparisonConfiguration.Builder#withEqualsForFields(java.util.function.BiPredicate, String...) RecursiveComparisonConfiguration.Builder#withComparatorForFields(Comparator, String...)
<C> AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingComparatorForElementFieldsWithType(Comparator<C> comparator, Class<C> type) Deprecated. This method is used with usingFieldByFieldElementComparator() which is deprecated in favor of usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration) or AbstractAssert.usingRecursiveComparison(). When using AbstractAssert.usingRecursiveComparison() the equivalent is: RecursiveComparisonAssert.withEqualsForType(java.util.function.BiPredicate, Class) RecursiveComparisonAssert.withComparatorForType(Comparator, Class) and when using RecursiveComparisonConfiguration: RecursiveComparisonConfiguration.Builder#withEqualsForType(java.util.function.BiPredicate, Class) RecursiveComparisonConfiguration.Builder#withComparatorForType(Comparator, Class)
<C> AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingComparatorForType(Comparator<C> comparator, Class<C> type) Allows to set a specific comparator for the given type of elements or their fields.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingDefaultElementComparator() Revert to standard comparison for incoming assertion group element checks.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingElementComparator(Comparator<? super T> elementComparator) Use given custom comparator instead of relying on actual element type equals method to compare AtomicReferenceArray elements for incoming assertion checks.
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingElementComparatorIgnoringFields(String... fields) Deprecated. This method is deprecated because it performs a shallow field by field comparison, i.e. elements are compared field by field but the fields are compared with equals, use usingRecursiveFieldByFieldElementComparatorIgnoringFields(String...) instead. See https://assertj.github.io/doc/#assertj-core-recursive-comparison
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingElementComparatorOnFields(String... fields) Deprecated. This method is deprecated because it performs a shallow field by field comparison, i.e. elements are compared field by field but the fields are compared with equals, use usingRecursiveFieldByFieldElementComparatorOnFields(String...) instead. See https://assertj.github.io/doc/#assertj-core-recursive-comparison
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingFieldByFieldElementComparator() Deprecated. This method is deprecated because it performs a shallow field by field comparison, i.e. elements are compared field by field but the fields are compared with equals, use usingRecursiveFieldByFieldElementComparator() or AbstractAssert.usingRecursiveComparison() instead to perform a true recursive comparison. See https://assertj.github.io/doc/#assertj-core-recursive-comparison
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparator() Enable using a recursive field by field comparison strategy similar to AbstractAssert.usingRecursiveComparison() but contrary to the latter you can chain any iterable assertions after this method (this is why this method exists).
AtomicReferenceArrayAssert<T>	AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration configuration) Enable using a recursive field by field comparison strategy similar to AbstractAssert.usingRecursiveComparison() but contrary to the latter you can chain any iterable assertions after this method (this is why this method exists).
AtomicReferenceArrayAssert<T>	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 element equals method.
AtomicReferenceArrayAssert<T>	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 element equals method.

Methods in org.assertj.core.api that return types with arguments of type AtomicReferenceArrayAssert

Modifier and Type	Method and Description
static <ELEMENT> InstanceOfAssertFactory<AtomicReferenceArray,AtomicReferenceArrayAssert<ELEMENT>>	InstanceOfAssertFactories.atomicReferenceArray(Class<ELEMENT> elementType) InstanceOfAssertFactory for an AtomicReferenceArray.