Uses of Class
org.assertj.core.api.AtomicReferenceArrayAssert
Packages that use AtomicReferenceArrayAssert
-
Uses of AtomicReferenceArrayAssert in org.assertj.core.api
Methods in org.assertj.core.api that return AtomicReferenceArrayAssertModifier 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.anySatisfy
(Consumer<? super T> requirements) Verifies that at least one element satisfies the given requirements expressed as aConsumer
.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
.<ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6AbstractStandardSoftAssertions.assertThat
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6Assertions.assertThat
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
WithAssertions.assertThat
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.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.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.AtomicReferenceArrayAssert.containsExactlyInAnyOrder
(T... values) Verifies that the actual AtomicReferenceArray contains exactly the given values and nothing else, in any order.AtomicReferenceArrayAssert.containsNull()
Verifies that the actual AtomicReferenceArray contains at least a null element.AtomicReferenceArrayAssert.containsOnly
(T... values) Verifies that the actual AtomicReferenceArray contains only the given values and nothing else, in any order.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.AtomicReferenceArrayAssert.containsOnlyOnce
(T... values) Verifies that the actual AtomicReferenceArray contains the given values only once.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.containsSequence
(T... sequence) Verifies that the actual AtomicReferenceArray contains the given sequence in the correct order and without extra values between the sequence values.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.containsSubsequence
(T... subsequence) Verifies that the actual AtomicReferenceArray contains the given subsequence in the correct order (possibly with other values between them).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.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.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.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.doesNotContainSubsequence
(T... subsequence) Verifies that the actual AtomicReferenceArray does not contain the given subsequence in the correct order (possibly with other values between them).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.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
(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.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.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.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.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
.AtomicReferenceArrayAssert.isSubsetOf
(T... values) Verifies that all elements of actual are present in the given values.AtomicReferenceArrayAssert.startsWith
(T... sequence) Verifies that the actual AtomicReferenceArray starts with the given sequence of objects, without any other objects between them.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
BDDAssertions.then
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.<ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6AbstractBDDSoftAssertions.then
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>
Java6BDDAssertions.then
(AtomicReferenceArray<ELEMENT> actual) Create assertion forAtomicReferenceArray
.AtomicReferenceArrayAssert.usingComparatorForElementFieldsWithNames
(Comparator<C> comparator, String... elementPropertyOrFieldNames) Allows to set a comparator to compare properties or fields of elements with the given names.AtomicReferenceArrayAssert.usingComparatorForElementFieldsWithType
(Comparator<C> comparator, Class<C> type) Allows to set a specific comparator to compare properties or fields of elements with the given type.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) Use field/property by field/property on all fields/properties except the given ones (including inherited fields/properties)instead of relying on actual type Aequals
method to compare AtomicReferenceArray elements for incoming assertion checks.AtomicReferenceArrayAssert.usingElementComparatorOnFields
(String... fields) Use field/property by field/property comparison on the given fields/properties only (including inherited fields/properties)instead of relying on actual type Aequals
method to compare AtomicReferenceArray elements for incoming assertion checks.AtomicReferenceArrayAssert.usingFieldByFieldElementComparator()
Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type Aequals
method to compare AtomicReferenceArray elements for incoming assertion checks.AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparator()
Use a recursive field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type Aequals
method to compare AtomicReferenceArray elements for incoming assertion checks.