Top Fields Constructors Methods
org.assertj.core.api

public Class AtomicReferenceArrayAssert<T>

extends AbstractAssert<AtomicReferenceArrayAssert<T>, AtomicReferenceArray<T>>
implements IndexedObjectEnumerableAssert<AtomicReferenceArrayAssert<T>, T>, ArraySortedAssert<AtomicReferenceArrayAssert<T>, T>
Class Inheritance
All Implemented Interfaces
org.assertj.core.api.ArraySortedAssert, org.assertj.core.api.IndexedObjectEnumerableAssert, org.assertj.core.api.ObjectEnumerableAssert, org.assertj.core.api.EnumerableAssert
Annotations
@SuppressWarnings:deprecation, RedundantSuppression
Static Imports
java.util.Arrays.stream, java.util.stream.Collectors.toList, org.assertj.core.api.filter.Filters.filter, org.assertj.core.description.Description.mostRelevantDescription, org.assertj.core.extractor.Extractors.byName, .Extractors.extractedDescriptionOf, .Extractors.extractedDescriptionOfMethod, .Extractors.resultOf, org.assertj.core.internal.CommonValidations.checkSequenceIsNotNull, .CommonValidations.checkSubsequenceIsNotNull, .TypeComparators.defaultTypeComparators, org.assertj.core.util.Arrays.array, .Arrays.isArray, .IterableUtil.toArray, .Lists.newArrayList, .Preconditions.checkArgument, .Preconditions.checkNotNull

Field Summary

Modifier and TypeField and Description
private final T[]
array

pack-priv ObjectArrays
arrays

private TypeComparators
comparatorsByType

private final Map<String, Comparator<?>>
comparatorsForElementPropertyOrFieldNames

private TypeComparators
comparatorsForElementPropertyOrFieldTypes

pack-priv Iterables
iterables

Inherited from org.assertj.core.api.AbstractAssert:
actualassertionErrorCreatorconditionscustomRepresentationinfomyselfobjectsprintAssertionsDescriptionthrowUnsupportedExceptionOnEquals

Constructor Summary

AccessConstructor and Description
public
AtomicReferenceArrayAssert(AtomicReferenceArray<T> actual)

Method Summary

Modifier and TypeMethod and Description
public AtomicReferenceArrayAssert<T>

Returns:

this object.
allMatch(Predicate<? super T>
the given Predicate.
predicate)

Implements org.assertj.core.api.ObjectEnumerableAssert.allMatch.

Verifies that all elements match the given Predicate.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
allMatch(Predicate<? super T>
the given Predicate.
predicate, String
a description of the Predicate used in the error message
predicateDescription)

Implements org.assertj.core.api.ObjectEnumerableAssert.allMatch.

Verifies that all the elements of actual's array match the given Predicate.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
allSatisfy(Consumer<? super T>
the given Consumer.
requirements)

Implements org.assertj.core.api.ObjectEnumerableAssert.allSatisfy.

Verifies that all the elements satisfy given requirements expressed as a Consumer.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
allSatisfy(ThrowingConsumer<? super T>
the given ThrowingConsumer.
requirements)

Implements org.assertj.core.api.ObjectEnumerableAssert.allSatisfy.

Verifies that all the elements satisfy the given requirements expressed as a ThrowingConsumer.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
anyMatch(Predicate<? super T>
the given Predicate.
predicate)

Implements org.assertj.core.api.ObjectEnumerableAssert.anyMatch.

Verifies whether any elements match the provided Predicate.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
anySatisfy(Consumer<? super T>
the given Consumer.
requirements)

Implements org.assertj.core.api.ObjectEnumerableAssert.anySatisfy.

Verifies that at least one element satisfies the given requirements expressed as a Consumer.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
anySatisfy(ThrowingConsumer<? super T>
the given ThrowingConsumer.
requirements)

Implements org.assertj.core.api.ObjectEnumerableAssert.anySatisfy.

Verifies that at least one element satisfies the given requirements expressed as a ThrowingConsumer.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
are(Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.are.

Verifies that each element value satisfies the given condition

Example : 

 AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});
AtomicReferenceArray<String> abcc = new AtomicReferenceArray<>(new String[]{"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);
public AtomicReferenceArrayAssert<T>

Returns:

this object.
areAtLeast(int
the minimum number of times the condition should be verified.
times, Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.areAtLeast.

Verifies that there are at least n elements in the actual AtomicReferenceArray satisfying the given condition.
public AtomicReferenceArrayAssert<T>
areAtLeastOne(Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.areAtLeastOne.

Verifies that there is at least one element in the actual AtomicReferenceArray satisfying the given condition.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
areAtMost(int
the number of times the condition should be at most verified.
times, Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.areAtMost.

Verifies that there are at most n elements in the actual AtomicReferenceArray satisfying the given condition.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
areExactly(int
the exact number of times the condition should be verified.
times, Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.areExactly.

Verifies that there are exactly n elements in the actual AtomicReferenceArray satisfying the given condition.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
areNot(Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.areNot.

Verifies that each element value does not satisfy the given condition

Example : 

 AtomicReferenceArray<String> abc = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});
AtomicReferenceArray<String> abcc = new AtomicReferenceArray<>(new String[]{"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);
public AtomicReferenceArrayAssert<T>
as(Description
the new description to set.
description)

Overrides default org.assertj.core.api.Descriptable.as.

Sets the description of the assertion that is going to be called after.
public AtomicReferenceArrayAssert<T>
as(String
the new description to set.
description, Object...
optional parameter if description is a format String.
args)

Overrides default org.assertj.core.api.Descriptable.as.

Sets the description of the assertion that is going to be called after.
public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
contains(T...
the given values.
values)

Implements org.assertj.core.api.ObjectEnumerableAssert.contains.

Verifies that the actual AtomicReferenceArray contains the given values, in any order.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
contains(T
the object to look for.
value, Index
the index where the object should be stored in the actual AtomicReferenceArray.
index)

Implements org.assertj.core.api.IndexedObjectEnumerableAssert.contains.

Verifies that the actual AtomicReferenceArray contains the given object at the given index.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsAll(Iterable<? extends T>
the given Iterable we will get elements from.
iterable)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsAll.

Verifies that the actual AtomicReferenceArray contains all the elements of given Iterable, in any order.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsAnyElementsOf(Iterable<? extends T>
the iterable whose at least one element is expected to be in the AtomicReferenceArray under test.
iterable)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsAnyElementsOf.

Verifies that the actual AtomicReferenceArray contains at least one of the given Iterable elements.
public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsAnyOf(T...
the values whose at least one which is expected to be in the AtomicReferenceArray under test.
values)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsAnyOf.

Verifies that the actual AtomicReferenceArray contains at least one of the given values.
protected AtomicReferenceArrayAssert<T>
containsAnyOfForProxy(T[] values)

public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsExactly(T...
the given values.
values)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsExactly.

Verifies that the actual AtomicReferenceArray contains only the given values and nothing else, in order.
public AtomicReferenceArrayAssert<T>
containsExactlyElementsOf(Iterable<? extends T>
the given Iterable we will get elements from.
iterable)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsExactlyElementsOf.

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>
containsExactlyForProxy(T[] values)

public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsExactlyInAnyOrder(T...
the given values.
values)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsExactlyInAnyOrder.

Verifies that the actual AtomicReferenceArray contains exactly the given values and nothing else, in any order.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsExactlyInAnyOrderElementsOf(Iterable<? extends T>
the given values.
values)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsExactlyInAnyOrderElementsOf.

Verifies that the actual AtomicReferenceArray contains exactly the given values and nothing else, in any order.
protected AtomicReferenceArrayAssert<T>
containsExactlyInAnyOrderForProxy(T[] values)

protected AtomicReferenceArrayAssert<T>
containsForProxy(T[] values)

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsNull()

Implements org.assertj.core.api.ObjectEnumerableAssert.containsNull.

Verifies that the actual AtomicReferenceArray contains at least a null element.
public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsOnly(T...
the given values.
values)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsOnly.

Verifies that the actual AtomicReferenceArray 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)..
public AtomicReferenceArrayAssert<T>
containsOnlyElementsOf(Iterable<? extends T>
the given Iterable we will get elements from.
iterable)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsOnlyElementsOf.

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. once a value is found, its duplicates are also considered found).
protected AtomicReferenceArrayAssert<T>
containsOnlyForProxy(T[] values)

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsOnlyNulls()

Implements org.assertj.core.api.ObjectEnumerableAssert.containsOnlyNulls.

Verifies that the actual AtomicReferenceArray contains only null elements and nothing else.
public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsOnlyOnce(T...
the given values.
values)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsOnlyOnce.

Verifies that the actual AtomicReferenceArray contains the given values only once.
public AtomicReferenceArrayAssert<T>
containsOnlyOnceElementsOf(Iterable<? extends T>
the given Iterable we will get elements from.
iterable)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsOnlyOnceElementsOf.

Same semantic as containsOnlyOnce(Object...) : verifies that the actual group contains the elements of the given iterable only once.
protected AtomicReferenceArrayAssert<T>
containsOnlyOnceForProxy(T[] values)

public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsSequence(T...
the sequence of objects to look for.
sequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsSequence.

Verifies that the actual AtomicReferenceArray contains the given sequence in the correct order and without extra values between the sequence values.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsSequence(Iterable<? extends T>
the sequence of objects to look for.
sequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsSequence.

Verifies that the actual AtomicReferenceArray contains the given sequence in the correct order and without extra values between the sequence values.
protected AtomicReferenceArrayAssert<T>
containsSequenceForProxy(T[] sequence)

public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsSubsequence(T...
the subsequence of objects to look for.
subsequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsSubsequence.

Verifies that the actual AtomicReferenceArray contains the given subsequence in the correct order (possibly with other values between them).
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
containsSubsequence(Iterable<? extends T>
the subsequence of objects to look for.
subsequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.containsSubsequence.

Verifies that the actual AtomicReferenceArray contains the given subsequence in the correct order (possibly with other values between them).
protected AtomicReferenceArrayAssert<T>
containsSubsequenceForProxy(T[] subsequence)

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
doesNotContain(T
the object to look for.
value, Index
the index where the object should not be stored in the actual AtomicReferenceArray.
index)

Implements org.assertj.core.api.IndexedObjectEnumerableAssert.doesNotContain.

Verifies that the actual AtomicReferenceArray does not contain the given object at the given index.
public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
doesNotContain(T...
the given values.
values)

Implements org.assertj.core.api.ObjectEnumerableAssert.doesNotContain.

Verifies that the actual AtomicReferenceArray does not contain the given values.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
doesNotContainAnyElementsOf(Iterable<? extends T>
the Iterable whose elements must not be in the actual AtomicReferenceArray.
iterable)

Implements org.assertj.core.api.ObjectEnumerableAssert.doesNotContainAnyElementsOf.

Verifies that the actual AtomicReferenceArray does not contain any elements of the given Iterable (i.e. none).
protected AtomicReferenceArrayAssert<T>
doesNotContainForProxy(T[] values)

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
doesNotContainNull()

Implements org.assertj.core.api.ObjectEnumerableAssert.doesNotContainNull.

Verifies that the actual AtomicReferenceArray does not contain null elements.
public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
doesNotContainSequence(T...
the sequence of objects to look for.
sequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.doesNotContainSequence.

Verifies that the actual AtomicReferenceArray contains the given sequence in the given order and without extra values between the sequence values.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
doesNotContainSequence(Iterable<? extends T>
the sequence of objects to look for.
sequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.doesNotContainSequence.

Verifies that the actual AtomicReferenceArray contains the given sequence in the given order and without extra values between the sequence values.
protected AtomicReferenceArrayAssert<T>
doesNotContainSequenceForProxy(T[] sequence)

public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
doesNotContainSubsequence(T...
the subsequence of objects to look for.
subsequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.doesNotContainSubsequence.

Verifies that the actual AtomicReferenceArray does not contain the given subsequence in the correct order (possibly with other values between them).
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
doesNotContainSubsequence(Iterable<? extends T>
the subsequence of objects to look for.
subsequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.doesNotContainSubsequence.

Verifies that the actual AtomicReferenceArray does not contain the given subsequence in the correct order (possibly with other values between them).
protected AtomicReferenceArrayAssert<T>
doesNotContainSubsequenceForProxy(T[] subsequence)

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
doesNotHaveAnyElementsOfTypes(Class<?>...
the not expected types.
unexpectedTypes)

Implements org.assertj.core.api.ObjectEnumerableAssert.doesNotHaveAnyElementsOfTypes.

Verifies that all the elements in the actual AtomicReferenceArray do not belong to the specified types (including subclasses).
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
doesNotHaveDuplicates()

Implements org.assertj.core.api.ObjectEnumerableAssert.doesNotHaveDuplicates.

Verifies that the actual AtomicReferenceArray does not contain duplicates.
private <U, C extends Collection<U>> ObjectArrayAssert<U>
doFlatExtracting(Function<? super T, C> extractor)

public AtomicReferenceArrayAssert<T>

Returns:

this object.
doNotHave(Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.doNotHave.

Verifies that all elements don't satisfy the given condition.
public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
endsWith(T
the first element of the end sequence of objects to look for.
first, T...
the rest of the end sequence of objects to look for.
sequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.endsWith.

Verifies that the actual AtomicReferenceArray ends with the given sequence of objects, without any other objects between them.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
endsWith(T[]
the (possibly empty) sequence of objects to look for.
sequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.endsWith.

Verifies that the actual AtomicReferenceArray ends with the given sequence of objects, without any other objects between them.
protected AtomicReferenceArrayAssert<T>
endsWithForProxy(T first, T[] sequence)

public ObjectArrayAssert<Object>

Returns:

a new assertion object whose object under test is the array of extracted field/property values.
extracting(String
the field/property to extract from the array under test
fieldOrProperty)

Extract the values of given field or property from the array's elements under test into a new array, this new array becoming the array under test.

public <
the extracted type
P> ObjectArrayAssert<P>

Returns:

a new assertion object whose object under test is the array of extracted field/property values.
extracting(String
the field/property to extract from the array under test
fieldOrProperty, Class<P>
type to return
extractingType)

Extract the values of given field or property from the array's elements under test into a new array, this new array becoming the array under test with type.

public ObjectArrayAssert<Tuple>

Returns:

a new assertion object whose object under test is the list of Tuple with extracted properties/fields values as data.
extracting(String...
the properties/fields to extract from the initial array under test
propertiesOrFields)

Extract the values of given fields/properties from the array's elements under test into a new array composed of Tuple (a simple data structure), this new array becoming the array under test.

public <
the extracted values type
U> ObjectArrayAssert<U>

Returns:

a new assertion object whose object under test is the list of values extracted
extracting(Function<? super T, U>
the object transforming input object to desired one
extractor)

Extract the values from the array's elements by applying an extracting function on them.

public <
the extracted values type
U,
the exception type
EXCEPTION extends Exception> ObjectArrayAssert<U>

Returns:

a new assertion object whose object under test is the list of values extracted
extracting(ThrowingExtractor<? super T, U, EXCEPTION>
the object transforming input object to desired one
extractor)

Extract the values from the array's elements by applying an extracting function (which might throw an exception) on them.

public ObjectArrayAssert<Object>

Returns:

a new assertion object whose object under test is the array of extracted values.
extractingResultOf(String
the name of the method which result is to be extracted from the array under test
method)

Extract the result of given method invocation from the array's elements under test into a new array, this new array becoming the array under test.

public <
the extracted type
P> ObjectArrayAssert<P>

Returns:

a new assertion object whose object under test is the array of extracted values.
extractingResultOf(String
the name of the method which result is to be extracted from the array under test
method, Class<P>
type to return
extractingType)

Extract the result of given method invocation from the array's elements under test into a new array, this new array becoming the array under test.

public AtomicReferenceArrayAssert<T>

Returns:

a new assertion object with the filtered array under test
filteredOn(String
the name of the property or field to read
propertyOrFieldName, Object
the value to compare element's property or field with
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.

public AtomicReferenceArrayAssert<T>

Returns:

a new assertion object with the filtered array under test
filteredOn(String
the name of the property or field to read
propertyOrFieldName, FilterOperator<?>
the filter operator to apply
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.

public AtomicReferenceArrayAssert<T>

Returns:

a new assertion object with the filtered array under test
filteredOn(Condition<? super T>
the filter condition / predicate
condition)

Filter the array under test keeping only elements matching the given Condition.

public AtomicReferenceArrayAssert<T>

Returns:

a new assertion object with the filtered array under test
filteredOn(Predicate<? super T>
the filter predicate
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.

public <
result type of the filter function
U> AtomicReferenceArrayAssert<T>

Returns:

a new assertion object with the filtered array under test
filteredOn(Function<? super T, U>
the filter function
function, U
the expected value of the filter function
expectedValue)

Filter the array under test into a list composed of the elements for which the result of the function is equal to expectedValue.

public AtomicReferenceArrayAssert<T>

Returns:

a new assertion object with the filtered array under test
filteredOnNull(String
the name of the property or field to read
propertyOrFieldName)

Filter the array under test keeping only elements whose property or field specified by propertyOrFieldName is null.

public <
the type of elements to extract.
U,
the type of collection to flat/extract.
C extends Collection<U>> ObjectArrayAssert<U>

Returns:

a new assertion object whose object under test is the list of values extracted
flatExtracting(Function<? super T, C>
the object transforming input object to an Iterable of desired ones
extractor)

Extract the Iterable values from the array's elements by applying an Iterable extracting function on them and concatenating the result lists into an array which becomes the new object under test.

public <
the type of elements to extract.
U,
the type of collection to flat/extract.
C extends Collection<U>,
the exception type
EXCEPTION extends Exception> ObjectArrayAssert<U>

Returns:

a new assertion object whose object under test is the list of values extracted
flatExtracting(ThrowingExtractor<? super T, C, EXCEPTION>
the object transforming input object to an Iterable of desired ones
extractor)

Extract the Iterable values from the array's elements by applying an Iterable extracting function (which might throw an exception) on them and concatenating the result lists into an array which becomes the new object under test.

public ObjectArrayAssert<Object>

Returns:

a new assertion object whose object under test is the list of values extracted
flatExtracting(String
the object transforming input object to an Iterable of desired ones
propertyName)

Extract from array's elements the Iterable/Array values corresponding to the given property/field name and concatenate them into a single array becoming the new object under test.

protected TypeComparators
getComparatorsByType()

protected TypeComparators
getComparatorsForElementPropertyOrFieldTypes()

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasArray(T[]
the array expected to be in the actual AtomicReferenceArray.
expected)

Verifies that the AtomicReferenceArray has the given array.

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasAtLeastOneElementOfType(Class<?>
the expected type.
expectedType)

Implements org.assertj.core.api.ObjectEnumerableAssert.hasAtLeastOneElementOfType.

Verifies that at least one element in the actual AtomicReferenceArray has the specified type (matching includes subclasses of the given type).
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasExactlyElementsOfTypes(Class<?>...
the expected types
expectedTypes)

Implements org.assertj.core.api.ObjectEnumerableAssert.hasExactlyElementsOfTypes.

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.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasOnlyElementsOfType(Class<?>
the expected type.
expectedType)

Implements org.assertj.core.api.ObjectEnumerableAssert.hasOnlyElementsOfType.

Verifies that all the elements in the actual AtomicReferenceArray belong to the specified type (matching includes subclasses of the given type).
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasOnlyElementsOfTypes(Class<?>...
the expected classes and interfaces
types)

Implements org.assertj.core.api.ObjectEnumerableAssert.hasOnlyElementsOfTypes.

Verifies that all elements of the actual group are instances of given classes or interfaces.
public AtomicReferenceArrayAssert<T>
hasOnlyOneElementSatisfying(Consumer<? super T>
the assertions to perform on the unique element.
elementAssertions)

Implements org.assertj.core.api.ObjectEnumerableAssert.hasOnlyOneElementSatisfying.

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.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object
hasSameElementsAs(Iterable<? extends T>
the Iterable whose elements we expect to be present
iterable)

Implements org.assertj.core.api.ObjectEnumerableAssert.hasSameElementsAs.

An alias of containsOnlyElementsOf(Iterable) : verifies that actual contains all elements of the given Iterable and nothing else, in any order.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasSameSizeAs(Object
the array to compare size with actual AtomicReferenceArray.
other)

Implements org.assertj.core.api.EnumerableAssert.hasSameSizeAs.

Verifies that the actual AtomicReferenceArray has the same size as the given array.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasSameSizeAs(Iterable<?>
the Iterable to compare size with actual AtomicReferenceArray.
other)

Implements org.assertj.core.api.EnumerableAssert.hasSameSizeAs.

Verifies that the actual AtomicReferenceArray has the same size as the given Iterable.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasSize(int
the expected number of values in the actual AtomicReferenceArray.
expected)

Implements org.assertj.core.api.EnumerableAssert.hasSize.

Verifies that the number of values in the AtomicReferenceArray is equal to the given one.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasSizeBetween(int
the lower boundary compared to which actual size should be greater than or equal to.
lowerBoundary, int
the higher boundary compared to which actual size should be less than or equal to.
higherBoundary)

Implements org.assertj.core.api.EnumerableAssert.hasSizeBetween.

Verifies that the number of values in the actual array is between the given boundaries (inclusive).
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasSizeGreaterThan(int
the given value to compare the actual size to.
boundary)

Implements org.assertj.core.api.EnumerableAssert.hasSizeGreaterThan.

Verifies that the number of values in the actual array is greater than the given boundary.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasSizeGreaterThanOrEqualTo(int
the given value to compare the actual size to.
boundary)

Implements org.assertj.core.api.EnumerableAssert.hasSizeGreaterThanOrEqualTo.

Verifies that the number of values in the actual array is greater than or equal to the given boundary.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasSizeLessThan(int
the given value to compare the actual size to.
boundary)

Implements org.assertj.core.api.EnumerableAssert.hasSizeLessThan.

Verifies that the number of values in the actual array is less than the given boundary.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
hasSizeLessThanOrEqualTo(int
the given value to compare the actual size to.
boundary)

Implements org.assertj.core.api.EnumerableAssert.hasSizeLessThanOrEqualTo.

Verifies that the number of values in the actual array is less than or equal to the given boundary.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
have(Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.have.

Verifies that all elements satisfy the given condition.
public AtomicReferenceArrayAssert<T>
haveAtLeast(int
the minimum number of times the condition must hold.
times, Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.haveAtLeast.

Verifies that there are at least n elements in the actual AtomicReferenceArray satisfying the given condition.
public AtomicReferenceArrayAssert<T>
haveAtLeastOne(Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.haveAtLeastOne.

Verifies that there is at least one element in the actual AtomicReferenceArray satisfying the given condition.
public AtomicReferenceArrayAssert<T>
haveAtMost(int
the maximum number of times the condition must hold.
times, Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.haveAtMost.

Verifies that there are at most n elements in the actual AtomicReferenceArray satisfying the given condition.
public AtomicReferenceArrayAssert<T>
haveExactly(int
the exact number of times the condition must hold.
times, Condition<? super T>
the given condition.
condition)

Implements org.assertj.core.api.ObjectEnumerableAssert.haveExactly.

Verifies that there are exactly n elements in the actual AtomicReferenceArray satisfying the given condition.
public AtomicReferenceArrayAssert<T>
inBinary()

Overrides org.assertj.core.api.AbstractAssert.inBinary.

Use binary object representation instead of standard representation in error messages.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
inHexadecimal()

Overrides org.assertj.core.api.AbstractAssert.inHexadecimal.

Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.
private AtomicReferenceArrayAssert<T>
internalAllSatisfy(Consumer<? super T> requirements)

private AtomicReferenceArrayAssert<T>
internalAnySatisfy(Consumer<? super T> requirements)

private AtomicReferenceArrayAssert<T>
internalFilteredOn(String propertyOrFieldName, Object expectedValue)

private AtomicReferenceArrayAssert<T>
internalFilteredOn(Predicate<? super T> predicate)

private AtomicReferenceArrayAssert<T>
internalNoneSatisfy(Consumer<? super T> restrictions)

public void
isEmpty()

Implements org.assertj.core.api.EnumerableAssert.isEmpty.

Verifies that the AtomicReferenceArray is empty.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
isNotEmpty()

Implements org.assertj.core.api.EnumerableAssert.isNotEmpty.

Verifies that the AtomicReferenceArray is not empty.
public void
isNullOrEmpty()

Implements org.assertj.core.api.EnumerableAssert.isNullOrEmpty.

Verifies that the AtomicReferenceArray is null or empty.
public AtomicReferenceArrayAssert<T>
isSorted()

Implements org.assertj.core.api.ArraySortedAssert.isSorted.

Verifies that the actual array is sorted in ascending order according to the natural ordering of its elements.
public AtomicReferenceArrayAssert<T>
isSortedAccordingTo(Comparator<? super T>
the Comparator used to compare array elements
comparator)

Implements org.assertj.core.api.ArraySortedAssert.isSortedAccordingTo.

Verifies that the actual array is sorted according to the given comparator.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
isSubsetOf(Iterable<? extends T>
the Iterable that should contain all actual elements.
values)

Implements org.assertj.core.api.ObjectEnumerableAssert.isSubsetOf.

Verifies that all elements of actual are present in the given Iterable.
public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
isSubsetOf(T...
the values that should be used for checking the elements of actual.
values)

Implements org.assertj.core.api.ObjectEnumerableAssert.isSubsetOf.

Verifies that all elements of actual are present in the given values.
protected AtomicReferenceArrayAssert<T>
isSubsetOfForProxy(T[] values)

public AtomicReferenceArrayAssert<T>

Returns:

this object.
noneMatch(Predicate<? super T>
the given Predicate.
predicate)

Implements org.assertj.core.api.ObjectEnumerableAssert.noneMatch.

Verifies that no elements match the given Predicate.
public AtomicReferenceArrayAssert<T>
noneSatisfy(Consumer<? super T>
the given restrictions as Consumer that no elements should met.
restrictions)

Implements org.assertj.core.api.ObjectEnumerableAssert.noneSatisfy.

Verifies that no elements satisfy the given restrictions expressed as a Consumer.
public AtomicReferenceArrayAssert<T>

Returns:

this object.
noneSatisfy(ThrowingConsumer<? super T>
the given ThrowingConsumer.
restrictions)

Implements org.assertj.core.api.ObjectEnumerableAssert.noneSatisfy.

Verifies that no elements satisfy the given restrictions expressed as a Consumer.
public final AtomicReferenceArrayAssert<T>

Returns:

this to chain assertions.
satisfiesExactly(Consumer<? super T>...
the requirements to meet.
requirements)

Implements org.assertj.core.api.ObjectEnumerableAssert.satisfiesExactly.

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...
public final AtomicReferenceArrayAssert<T>

Returns:

this to chain assertions.
satisfiesExactly(ThrowingConsumer<? super T>...
the requirements to meet.
requirements)

Implements org.assertj.core.api.ObjectEnumerableAssert.satisfiesExactly.

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>
satisfiesExactlyForProxy(Consumer<? super T>[] requirements)

public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
satisfiesExactlyInAnyOrder(Consumer<? super T>...
the consumers that are expected to be satisfied by the elements of the given Iterable.
requirements)

Implements org.assertj.core.api.ObjectEnumerableAssert.satisfiesExactlyInAnyOrder.

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).
public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
satisfiesExactlyInAnyOrder(ThrowingConsumer<? super T>...
the consumers that are expected to be satisfied by the elements of the given Iterable.
requirements)

Implements org.assertj.core.api.ObjectEnumerableAssert.satisfiesExactlyInAnyOrder.

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>
satisfiesExactlyInAnyOrderForProxy(Consumer<? super T>[] requirements)

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
satisfiesOnlyOnce(Consumer<? super T>
the Consumer that is expected to be satisfied only once by the elements of the given Iterable.
requirements)

Implements org.assertj.core.api.ObjectEnumerableAssert.satisfiesOnlyOnce.

Verifies that there is exactly one element in the AtomicReferenceArray under test that satisfies the Consumer.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
satisfiesOnlyOnce(ThrowingConsumer<? super T>
the ThrowingConsumer that is expected to be satisfied only once by the elements of the given Iterable.
requirements)

Implements org.assertj.core.api.ObjectEnumerableAssert.satisfiesOnlyOnce.

Verifies that there is exactly one element in the AtomicReferenceArray under test that satisfies the ThrowingConsumer.
protected AtomicReferenceArrayAssert<T>
satisfiesOnlyOnceForProxy(Consumer<? super T> requirements)

public final AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
startsWith(T...
the sequence of objects to look for.
sequence)

Implements org.assertj.core.api.ObjectEnumerableAssert.startsWith.

Verifies that the actual AtomicReferenceArray starts with the given sequence of objects, without any other objects between them.
protected AtomicReferenceArrayAssert<T>
startsWithForProxy(T[] sequence)

public <
the type to compare.
C> AtomicReferenceArrayAssert<T>

Returns:

this assertions object
usingComparatorForElementFieldsWithNames(Comparator<C>
the java.util.Comparator to use
comparator, String...
the names of the properties and/or fields of the elements the comparator should be used for
elementPropertyOrFieldNames)

Deprecated This method is used with usingFieldByFieldElementComparator() which is deprecated in favor of usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration) or usingRecursiveComparison().
Deprecated javadoc

Allows to set a comparator to compare properties or fields of elements with the given names.

public <
the type to compare.
C> AtomicReferenceArrayAssert<T>

Returns:

this assertions object
usingComparatorForElementFieldsWithType(Comparator<C>
the java.util.Comparator to use
comparator, Class<C>
the java.lang.Class of the type of the element fields the comparator should be used for
type)

Deprecated This method is used with usingFieldByFieldElementComparator() which is deprecated in favor of usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration) or usingRecursiveComparison().
Deprecated javadoc

Allows to set a specific comparator to compare properties or fields of elements with the given type.

public <
the type to compare.
C> AtomicReferenceArrayAssert<T>

Returns:

this assertions object
usingComparatorForType(Comparator<C>
the java.util.Comparator to use
comparator, Class<C>
the java.lang.Class of the type of the element or element fields the comparator should be used for
type)

Allows to set a specific comparator for the given type of elements or their fields.

public AtomicReferenceArrayAssert<T>
usingDefaultElementComparator()

Implements org.assertj.core.api.EnumerableAssert.usingDefaultElementComparator.

Revert to standard comparison for incoming assertion group element checks.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
usingElementComparator(Comparator<? super T>
the comparator to use for incoming assertion checks.
elementComparator)

Implements org.assertj.core.api.EnumerableAssert.usingElementComparator.

Use given custom comparator instead of relying on actual element type equals method to compare AtomicReferenceArray elements for incoming assertion checks.
public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
usingElementComparatorIgnoringFields(String...
the names of the fields/properties to ignore
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.
Deprecated javadoc

Use field/property by field/property on all fields/properties except the given ones (including inherited fields/properties) instead of relying on actual type A equals method to compare AtomicReferenceArray elements for incoming assertion checks.

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
usingElementComparatorOnFields(String...
the fields to compare field/property by field/property.
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.
Deprecated javadoc

Use field/property by field/property comparison on the given fields/properties only (including inherited fields/properties) instead of relying on actual type A equals method to compare AtomicReferenceArray elements for incoming assertion checks.

private AtomicReferenceArrayAssert<T>
usingExtendedByTypesElementComparator(Comparator<Object> elementComparator)

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
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 usingRecursiveComparison() instead to perform a true recursive comparison.
Deprecated javadoc

Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type A equals method to compare AtomicReferenceArray elements for incoming assertion checks.

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
usingRecursiveFieldByFieldElementComparator()

Enable using a recursive field by field comparison strategy similar to usingRecursiveComparison() but contrary to the latter you can chain any iterable assertions after this method (this is why this method exists).

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration
the recursive comparison configuration.
configuration)

Enable using a recursive field by field comparison strategy similar to usingRecursiveComparison() but contrary to the latter you can chain any iterable assertions after this method (this is why this method exists).

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
usingRecursiveFieldByFieldElementComparatorIgnoringFields(String...
the field names to exclude in the elements comparison.
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.

public AtomicReferenceArrayAssert<T>

Returns:

this assertion object.
usingRecursiveFieldByFieldElementComparatorOnFields(String...
the field names to exclude in the elements comparison.
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.

Inherited from org.assertj.core.api.AbstractAssert:
areEqualasInstanceOfasListassertionErrorasStringdescribedAsdescriptionTextdoesNotHavedoesNotHaveSameClassAsdoesNotHaveSameHashCodeAsdoesNotHaveToStringdoesNotHaveToStringequalsextractingextractingfailurefailureWithActualExpectedfailWithActualExpectedAndMessagefailWithMessagegetWritableAssertionInfohashashCodehasSameClassAshasSameHashCodeAshasToStringhasToStringisisElementOfCustomAssertisEqualToisExactlyInstanceOfisInisInisInstanceOfisInstanceOfAnyisInstanceOfSatisfyingisNotisNotEqualToisNotExactlyInstanceOfisNotInisNotInisNotInstanceOfisNotInstanceOfAnyisNotNullisNotOfAnyClassInisNotSameAsisNullisOfAnyClassInisSameAsmatchesmatchesnewListAssertInstanceoverridingErrorMessageoverridingErrorMessagesatisfiessatisfiessatisfiessatisfiesAnyOfsatisfiesAnyOfsatisfiesAnyOfForProxysatisfiesForProxysetCustomRepresentationsetDescriptionConsumersetPrintAssertionsDescriptionthrowAssertionErrorusingComparatorusingComparatorusingDefaultComparatorusingRecursiveAssertionusingRecursiveAssertionusingRecursiveComparisonusingRecursiveComparisonwithAssertionStatewithFailMessagewithFailMessagewithRepresentationwithThreadDumpOnError