SELF |
AbstractAssert.as(String description,
Object... args) |
Sets the description of the assertion that is going to be called after.
|
SELF |
AbstractAssert.as(Description description) |
Sets the description of the assertion that is going to be called after.
|
SELF |
AbstractIterableAssert.as(String description,
Object... args) |
|
SELF |
AbstractIterableAssert.as(Description description) |
|
SELF |
AbstractListAssert.as(String description,
Object... args) |
|
SELF |
AbstractListAssert.as(Description description) |
|
SELF |
AbstractMapAssert.as(String description,
Object... args) |
|
SELF |
AbstractMapAssert.as(Description description) |
|
SELF |
AbstractObjectAssert.as(String description,
Object... args) |
|
SELF |
AbstractObjectAssert.as(Description description) |
|
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.as(String description,
Object... args) |
|
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.as(Description description) |
|
ThrowableTypeAssert<T> |
ThrowableTypeAssert.as(String description,
Object... args) |
Sets the description of the assertion that is going to be called after.
|
ThrowableTypeAssert<T> |
ThrowableTypeAssert.as(Description description) |
Sets the description of the assertion that is going to be called after.
|
<ASSERT extends AbstractAssert<?,?>> ASSERT |
AbstractAssert.asInstanceOf(InstanceOfAssertFactory<?,ASSERT> instanceOfAssertFactory) |
Uses an InstanceOfAssertFactory to verify that the actual value is an instance of a given type and to produce
a new Assert narrowed to that type.
|
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> |
AbstractAssert.asList() |
Verifies that the actual value is an instance of List,
and returns a list assertion, to allow chaining of list-specific
assertions from this call.
|
AbstractStringAssert<?> |
AbstractAssert.asString() |
Returns a String assertion for the toString() of the actual
value, to allow chaining of String-specific assertions from this call.
|
SELF |
AbstractAssert.describedAs(String description,
Object... args) |
Sets the description of the assertion that is going to be called after.
|
SELF |
AbstractAssert.describedAs(Description description) |
Sets the description of the assertion that is going to be called after.
|
SELF |
AbstractIterableAssert.describedAs(String description,
Object... args) |
|
SELF |
AbstractIterableAssert.describedAs(Description description) |
|
SELF |
AbstractListAssert.describedAs(String description,
Object... args) |
|
SELF |
AbstractListAssert.describedAs(Description description) |
|
SELF |
AbstractMapAssert.describedAs(String description,
Object... args) |
|
SELF |
AbstractMapAssert.describedAs(Description description) |
|
ThrowableAssertAlternative<T> |
ThrowableAssertAlternative.describedAs(String description,
Object... args) |
Sets the description of the assertion that is going to be called after.
|
ThrowableAssertAlternative<T> |
ThrowableAssertAlternative.describedAs(Description description) |
Sets the description of the assertion that is going to be called after.
|
ThrowableTypeAssert<T> |
ThrowableTypeAssert.describedAs(String description,
Object... args) |
Sets the description of the assertion that is going to be called after.
|
ThrowableTypeAssert<T> |
ThrowableTypeAssert.describedAs(Description description) |
Sets the description of the assertion that is going to be called after.
|
ELEMENT_ASSERT |
AbstractIterableAssert.element(int index) |
Navigate and allow to perform assertions on the chosen element of the Iterable under test.
|
<ASSERT extends AbstractAssert<?,?>> ASSERT |
AbstractIterableAssert.element(int index,
InstanceOfAssertFactory<?,ASSERT> assertFactory) |
Navigate and allow to perform assertions on the chosen element of the Iterable under test.
|
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
AbstractIterableAssert.extracting(String propertyOrField) |
Extract the values of the given field or property from the Iterable's elements under test into a new Iterable, this new
Iterable becoming the Iterable under test.
|
AbstractListAssert<?,List<? extends Tuple>,Tuple,ObjectAssert<Tuple>> |
AbstractIterableAssert.extracting(String... propertiesOrFields) |
Extract the values of the given fields/properties from the Iterable's elements under test into a new Iterable composed
of Tuples (a simple data structure), this new Iterable becoming the Iterable under test.
|
<P> AbstractListAssert<?,List<? extends P>,P,ObjectAssert<P>> |
AbstractIterableAssert.extracting(String propertyOrField,
Class<P> extractingType) |
Extract the values of given field or property from the Iterable's elements under test into a new Iterable, this new
Iterable becoming the Iterable under test.
|
AbstractListAssert<?,List<? extends Tuple>,Tuple,ObjectAssert<Tuple>> |
AbstractIterableAssert.extracting(Function<? super ELEMENT,?>... extractors) |
Use the given Function s to extract the values from the Iterable 's elements into a new Iterable
composed of Tuple s (a simple data structure containing the extracted values), this new Iterable becoming the
object under test.
|
<V> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> |
AbstractIterableAssert.extracting(Function<? super ELEMENT,V> extractor) |
Extract the values from Iterable's elements under test by applying an extracting function on them.
|
<V,EXCEPTION extends Exception> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> |
AbstractIterableAssert.extracting(ThrowingExtractor<? super ELEMENT,V,EXCEPTION> extractor) |
Extract the values from Iterable's elements under test by applying an extracting function (which might throw an
exception) on them.
|
AbstractObjectAssert<?,?> |
AbstractMapAssert.extracting(Object key) |
Deprecated.
|
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> |
AbstractMapAssert.extracting(Object... keys) |
Deprecated.
|
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
AbstractObjectArrayAssert.extracting(String fieldOrProperty) |
Extract the values of given field or property from the array's elements under test into a new list, this new list
becoming the object under test.
|
AbstractListAssert<?,List<? extends Tuple>,Tuple,ObjectAssert<Tuple>> |
AbstractObjectArrayAssert.extracting(String... propertiesOrFields) |
Extract the values of given fields/properties from the array's elements under test into a list composed of
Tuple (a simple data structure), this new list becoming the object under test.
|
<P> AbstractListAssert<?,List<? extends P>,P,ObjectAssert<P>> |
AbstractObjectArrayAssert.extracting(String fieldOrProperty,
Class<P> extractingType) |
Extract the values of given field or property from the array's elements under test into a new list, this new list of the provided type
becoming the object under test.
|
AbstractListAssert<?,List<? extends Tuple>,Tuple,ObjectAssert<Tuple>> |
AbstractObjectArrayAssert.extracting(Function<? super ELEMENT,?>... extractors) |
Use the given Function s to extract the values from the array's elements into a new list
composed of Tuple s (a simple data structure containing the extracted values), this new list becoming the
object under test.
|
<U> AbstractListAssert<?,List<? extends U>,U,ObjectAssert<U>> |
AbstractObjectArrayAssert.extracting(Function<? super ELEMENT,U> extractor) |
Extract the values from the array's elements by applying an extracting function on them, the resulting list becomes
the new object under test.
|
<V,EXCEPTION extends Exception> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> |
AbstractObjectArrayAssert.extracting(ThrowingExtractor<? super ELEMENT,V,EXCEPTION> extractor) |
Extract the values from the array's elements by applying an extracting function (which might throw an exception)
on them, the resulting list of extracted values becomes a new object under test.
|
AbstractObjectAssert<?,?> |
AbstractObjectAssert.extracting(String propertyOrField) |
Extracts the value of given field/property from the object under test, the extracted value becoming the new object under test.
|
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> |
AbstractObjectAssert.extracting(String... propertiesOrFields) |
Extracts the values of given fields/properties from the object under test into a list, this new list becoming
the object under test.
|
<ASSERT extends AbstractAssert<?,?>> ASSERT |
AbstractObjectAssert.extracting(String propertyOrField,
InstanceOfAssertFactory<?,ASSERT> assertFactory) |
Extracts the value of given field/property from the object under test, the extracted value becoming the new object under test.
|
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> |
AbstractObjectAssert.extracting(Function<? super ACTUAL,?>... extractors) |
Uses the given Function s to extract the values from the object under test into a list, this new list becoming
the object under test.
|
<T> AbstractObjectAssert<?,T> |
AbstractObjectAssert.extracting(Function<? super ACTUAL,T> extractor) |
Uses the given Function to extract a value from the object under test, the extracted value becoming the new object under test.
|
<T,ASSERT extends AbstractAssert<?,?>> ASSERT |
AbstractObjectAssert.extracting(Function<? super ACTUAL,T> extractor,
InstanceOfAssertFactory<?,ASSERT> assertFactory) |
Uses the given Function to extract a value from the object under test, the extracted value becoming the new object under test.
|
ObjectArrayAssert<Object> |
AtomicReferenceArrayAssert.extracting(String 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.
|
ObjectArrayAssert<Tuple> |
AtomicReferenceArrayAssert.extracting(String... 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.
|
<P> ObjectArrayAssert<P> |
AtomicReferenceArrayAssert.extracting(String fieldOrProperty,
Class<P> 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.
|
<U> ObjectArrayAssert<U> |
AtomicReferenceArrayAssert.extracting(Function<? super T,U> extractor) |
Extract the values from the array's elements by applying an extracting function on them.
|
<U,EXCEPTION extends Exception> ObjectArrayAssert<U> |
AtomicReferenceArrayAssert.extracting(ThrowingExtractor<? super T,U,EXCEPTION> extractor) |
Extract the values from the array's elements by applying an extracting function (which might throw an
exception) on them.
|
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> |
ObjectAssert.extracting(Function<? super ACTUAL,?>... extractors) |
|
AbstractObjectAssert<?,V> |
AbstractMapAssert.extractingByKey(K key) |
Extract the value of given key from the map under test, the extracted value becoming the new object under test.
|
<ASSERT extends AbstractAssert<?,?>> ASSERT |
AbstractMapAssert.extractingByKey(K key,
InstanceOfAssertFactory<?,ASSERT> assertFactory) |
Extract the value of given key from the map under test, the extracted value becoming the new object under test.
|
AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> |
AbstractMapAssert.extractingByKeys(K... keys) |
Extract the values of given keys from the map under test into an array, this new array becoming
the object under test.
|
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> |
AbstractMapAssert.extractingFromEntries(Function<? super Map.Entry<K,V>,Object> extractor) |
Use the given Function to extract a value from the Map 's entries.
|
AbstractListAssert<?,List<? extends Tuple>,Tuple,ObjectAssert<Tuple>> |
AbstractMapAssert.extractingFromEntries(Function<? super Map.Entry<K,V>,Object>... extractors) |
Use the given Function s to extract values from the Map 's entries.
|
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
AbstractIterableAssert.extractingResultOf(String method) |
Extract the result of given method invocation on the Iterable's elements under test into a new Iterable, this new
Iterable becoming the Iterable under test.
|
<P> AbstractListAssert<?,List<? extends P>,P,ObjectAssert<P>> |
AbstractIterableAssert.extractingResultOf(String method,
Class<P> extractedType) |
Extract the result of given method invocation on the Iterable's elements under test into a new list of the given
class, this new List becoming the object under test.
|
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
AbstractObjectArrayAssert.extractingResultOf(String method) |
Extract the result of given method invocation from the array's elements under test into a list, this list becoming
the object under test.
|
<P> AbstractListAssert<?,List<? extends P>,P,ObjectAssert<P>> |
AbstractObjectArrayAssert.extractingResultOf(String method,
Class<P> extractingType) |
Extract the result of given method invocation from the array's elements under test into a list, this list becoming
the object under test.
|
ObjectArrayAssert<Object> |
AtomicReferenceArrayAssert.extractingResultOf(String 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.
|
<P> ObjectArrayAssert<P> |
AtomicReferenceArrayAssert.extractingResultOf(String method,
Class<P> 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.
|
SELF |
AbstractIterableAssert.filteredOn(String propertyOrFieldName,
Object expectedValue) |
Filter the iterable under test keeping only elements having a property or field equal to expectedValue , the
property/field is specified by propertyOrFieldName parameter.
|
SELF |
AbstractIterableAssert.filteredOn(String propertyOrFieldName,
FilterOperator<?> filterOperator) |
Filter the iterable 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.
|
SELF |
AbstractIterableAssert.filteredOn(Condition<? super ELEMENT> condition) |
Filter the iterable under test keeping only elements matching the given Condition .
|
SELF |
AbstractObjectArrayAssert.filteredOn(String propertyOrFieldName,
Object expectedValue) |
Filter the array under test into a list composed of the elements elements having a property or field equal to
expectedValue , the property/field is specified by propertyOrFieldName parameter.
|
SELF |
AbstractObjectArrayAssert.filteredOn(String propertyOrFieldName,
FilterOperator<?> filterOperator) |
Filter the array under test into a list composed of elements having a property or field matching the filter expressed with
the FilterOperator , the property/field is specified by propertyOrFieldName parameter.
|
SELF |
AbstractObjectArrayAssert.filteredOn(Condition<? super ELEMENT> condition) |
Filter the array under test into a list composed of the elements matching the given Condition ,
allowing to perform assertions on the filtered list.
|
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.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(Condition<? super T> condition) |
Filter the array under test keeping only elements matching the given Condition .
|
SELF |
AbstractIterableAssert.filteredOnNull(String propertyOrFieldName) |
Filter the iterable under test keeping only elements whose property or field specified by
propertyOrFieldName is null.
|
SELF |
AbstractObjectArrayAssert.filteredOnNull(String propertyOrFieldName) |
Filter the array under test into a list composed of the elements whose property or field specified
by propertyOrFieldName are null.
|
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.filteredOnNull(String propertyOrFieldName) |
Filter the array under test keeping only elements whose property or field specified by propertyOrFieldName
is null.
|
ELEMENT_ASSERT |
AbstractIterableAssert.first() |
Navigate and allow to perform assertions on the first element of the Iterable under test.
|
<ASSERT extends AbstractAssert<?,?>> ASSERT |
AbstractIterableAssert.first(InstanceOfAssertFactory<?,ASSERT> assertFactory) |
Navigate and allow to perform assertions on the first element of the Iterable under test.
|
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
AbstractIterableAssert.flatExtracting(String fieldOrPropertyName) |
Extract from Iterable's elements the Iterable/Array values corresponding to the given property/field name and
concatenate them into a single list becoming the new object under test.
|
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
AbstractIterableAssert.flatExtracting(String... fieldOrPropertyNames) |
Extract the given property/field values from each Iterable 's element and
flatten the extracted values in a list that is used as the new object under test.
|
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
AbstractIterableAssert.flatExtracting(Function<? super ELEMENT,?>... extractors) |
Extract multiple values from each Iterable 's element according to the given Function s
and concatenate/flatten the extracted values in a list that is used as the new object under test.
|
<V> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> |
AbstractIterableAssert.flatExtracting(Function<? super ELEMENT,? extends Collection<V>> extractor) |
Extract the Iterable values from Iterable's elements under test by applying an Iterable extracting function on them
and concatenating the result lists.
|
<EXCEPTION extends Exception> AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
AbstractIterableAssert.flatExtracting(ThrowingExtractor<? super ELEMENT,?,EXCEPTION>... extractors) |
Extract multiple values from each Iterable 's element according to the given ThrowingExtractor s
and concatenate/flatten the extracted values in a list that is used as the new object under test.
|
<V,EXCEPTION extends Exception> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> |
AbstractIterableAssert.flatExtracting(ThrowingExtractor<? super ELEMENT,? extends Collection<V>,EXCEPTION> extractor) |
Extract the Iterable values from Iterable's elements under test by applying an Iterable extracting function (which
might throw a checked exception) on them and concatenating the result lists.
|
AbstractListAssert<?,List<?>,Object,ObjectAssert<Object>> |
AbstractMapAssert.flatExtracting(String... keys) |
Flatten the values of the given keys from the actual map under test into a new array, this new array becoming the object under test.
|
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> |
AbstractObjectArrayAssert.flatExtracting(String 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.
|
<V,C extends Collection<V>> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> |
AbstractObjectArrayAssert.flatExtracting(Function<? super ELEMENT,C> extractor) |
Extract the Iterable values from arrays elements under test by applying an Iterable extracting function on them
and concatenating the result lists into an array which becomes the new object under test.
|
<V,C extends Collection<V>,EXCEPTION extends Exception> AbstractListAssert<?,List<? extends V>,V,ObjectAssert<V>> |
AbstractObjectArrayAssert.flatExtracting(ThrowingExtractor<? super ELEMENT,C,EXCEPTION> extractor) |
Extract the Iterable values from arrays elements under test 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.
|
ObjectArrayAssert<Object> |
AtomicReferenceArrayAssert.flatExtracting(String 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.
|
<U,C extends Collection<U>> ObjectArrayAssert<U> |
AtomicReferenceArrayAssert.flatExtracting(Function<? super T,C> 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.
|
<U,C extends Collection<U>,EXCEPTION extends Exception> ObjectArrayAssert<U> |
AtomicReferenceArrayAssert.flatExtracting(ThrowingExtractor<? super T,C,EXCEPTION> 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.
|
<U> AbstractOptionalAssert<?,U> |
AbstractOptionalAssert.flatMap(Function<? super VALUE,Optional<U>> mapper) |
Call flatMap on the Optional under test, assertions chained afterwards are performed on the Optional resulting from the flatMap call.
|
AbstractObjectAssert<?,VALUE> |
AbstractOptionalAssert.get() |
Verifies that the actual Optional is not null and not empty and returns an Object assertion
that allows chaining (object) assertions on the optional value.
|
<ASSERT extends AbstractAssert<?,?>> ASSERT |
AbstractOptionalAssert.get(InstanceOfAssertFactory<?,ASSERT> assertFactory) |
Verifies that the actual Optional is not null and not empty and returns an new assertion instance
to chain assertions on the optional value.
|
SELF |
RecursiveComparisonAssert.ignoringActualNullFields() |
Makes the recursive comparison to ignore all actual null fields (but note that the expected object null fields are used in the comparison).
|
SELF |
RecursiveComparisonAssert.ignoringCollectionOrder() |
Makes the recursive comparison to ignore collection order in all fields in the object under test.
|
SELF |
RecursiveComparisonAssert.ignoringCollectionOrderInFields(String... fieldsToIgnoreCollectionOrder) |
Makes the recursive comparison to ignore collection order in the object under test specified fields.
|
SELF |
RecursiveComparisonAssert.ignoringCollectionOrderInFieldsMatchingRegexes(String... regexes) |
Makes the recursive comparison to ignore collection order in the object under test fields matching the specified regexes.
|
SELF |
RecursiveComparisonAssert.ignoringFields(String... fieldsToIgnore) |
Makes the recursive comparison to ignore the given the object under test fields.
|
SELF |
RecursiveComparisonAssert.ignoringFieldsMatchingRegexes(String... regexes) |
Makes the recursive comparison to ignore the object under test fields matching the given regexes.
|
SELF |
RecursiveComparisonAssert.ignoringOverriddenEqualsForFields(String... fields) |
By default the recursive comparison uses overridden equals methods to compare fields,
this method allows to force a recursive comparison for the given fields (it adds them to the already registered ones).
|
SELF |
RecursiveComparisonAssert.ignoringOverriddenEqualsForFieldsMatchingRegexes(String... regexes) |
By default the recursive comparison uses overridden equals methods to compare fields,
this method allows to force a recursive comparison for the fields matching the given regexes (it adds them to the already registered ones).
|
SELF |
RecursiveComparisonAssert.ignoringOverriddenEqualsForTypes(Class<?>... types) |
By default the recursive comparison uses overridden equals methods to compare fields,
this method allows to force a recursive comparison for all fields of the given types (it adds them to the already registered ones).
|
protected SELF |
AbstractAssert.inBinary() |
Use binary object representation instead of standard representation in error messages.
|
SELF |
AbstractComparableAssert.inBinary() |
|
SELF |
AbstractEnumerableAssert.inBinary() |
|
SELF |
AbstractIterableAssert.inBinary() |
Enable binary representation of Iterable elements instead of standard representation in error messages.
|
SELF |
AbstractObjectArrayAssert.inBinary() |
|
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.inBinary() |
|
protected SELF |
AbstractAssert.inHexadecimal() |
Use hexadecimal object representation instead of standard representation in error messages.
|
SELF |
AbstractCharSequenceAssert.inHexadecimal() |
|
SELF |
AbstractComparableAssert.inHexadecimal() |
|
SELF |
AbstractEnumerableAssert.inHexadecimal() |
Enable hexadecimal object representation of Iterable elements instead of standard java representation in error messages.
|
SELF |
AbstractIterableAssert.inHexadecimal() |
Enable hexadecimal representation of Iterable elements instead of standard representation in error messages.
|
SELF |
AbstractObjectArrayAssert.inHexadecimal() |
Enable hexadecimal object representation of Iterable elements instead of standard java representation in error
messages.
|
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.inHexadecimal() |
Enable hexadecimal object representation of Iterable elements instead of standard java representation in error
messages.
|
SELF |
AbstractCharacterAssert.inUnicode() |
Use unicode character representation instead of standard representation in error messages.
|
SELF |
AbstractCharArrayAssert.inUnicode() |
Use unicode character representation instead of standard representation in error messages.
|
SELF |
AbstractCharSequenceAssert.inUnicode() |
Use unicode character representation instead of standard representation in error messages.
|
AtomicLongArrayAssert |
AtomicLongArrayAssert.isNotEmpty() |
Verifies that the AtomicLongArray is not empty.
|
ELEMENT_ASSERT |
AbstractIterableAssert.last() |
Navigate and allow to perform assertions on the last element of the Iterable under test.
|
<ASSERT extends AbstractAssert<?,?>> ASSERT |
AbstractIterableAssert.last(InstanceOfAssertFactory<?,ASSERT> assertFactory) |
Navigate and allow to perform assertions on the last element of the Iterable under test.
|
<U> AbstractOptionalAssert<?,U> |
AbstractOptionalAssert.map(Function<? super VALUE,? extends U> mapper) |
Call map on the Optional under test, assertions chained afterwards are performed on the Optional resulting from the map call.
|
SELF |
AbstractAssert.overridingErrorMessage(String newErrorMessage,
Object... args) |
Overrides AssertJ default error message by the given one.
|
SELF |
AbstractIterableAssert.overridingErrorMessage(String newErrorMessage,
Object... args) |
|
SELF |
AbstractListAssert.overridingErrorMessage(String newErrorMessage,
Object... args) |
|
SELF |
AbstractMapAssert.overridingErrorMessage(String newErrorMessage,
Object... args) |
|
AbstractIterableAssert<IterableAssert<T>,Iterable<? extends T>,T,ObjectAssert<T>> |
IterableSizeAssert.returnToIterable() |
|
AbstractMapAssert<MapAssert<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE> |
MapSizeAssert.returnToMap() |
|
AbstractIterableSizeAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT> |
AbstractIterableAssert.size() |
Returns an Assert object that allows performing assertions on the size of the Iterable under test.
|
AbstractMapSizeAssert<SELF,ACTUAL,K,V> |
AbstractMapAssert.size() |
Returns an Assert object that allows performing assertions on the size of the Map under test.
|
PathAssert |
AbstractBDDSoftAssertions.then(Path actual) |
|
InstantAssert |
AbstractBDDSoftAssertions.then(Instant actual) |
|
LocalDateAssert |
AbstractBDDSoftAssertions.then(LocalDate actual) |
|
LocalDateTimeAssert |
AbstractBDDSoftAssertions.then(LocalDateTime actual) |
|
LocalTimeAssert |
AbstractBDDSoftAssertions.then(LocalTime actual) |
|
OffsetDateTimeAssert |
AbstractBDDSoftAssertions.then(OffsetDateTime actual) |
|
OffsetTimeAssert |
AbstractBDDSoftAssertions.then(OffsetTime actual) |
|
ZonedDateTimeAssert |
AbstractBDDSoftAssertions.then(ZonedDateTime actual) |
|
<RESULT> CompletableFutureAssert<RESULT> |
AbstractBDDSoftAssertions.then(CompletableFuture<RESULT> actual) |
|
<RESULT> CompletableFutureAssert<RESULT> |
AbstractBDDSoftAssertions.then(CompletionStage<RESULT> actual) |
|
DoublePredicateAssert |
AbstractBDDSoftAssertions.then(DoublePredicate actual) |
|
IntPredicateAssert |
AbstractBDDSoftAssertions.then(IntPredicate actual) |
|
LongPredicateAssert |
AbstractBDDSoftAssertions.then(LongPredicate actual) |
|
<T> ProxyablePredicateAssert<T> |
AbstractBDDSoftAssertions.then(Predicate<T> actual) |
|
<VALUE> OptionalAssert<VALUE> |
AbstractBDDSoftAssertions.then(Optional<VALUE> actual) |
|
OptionalDoubleAssert |
AbstractBDDSoftAssertions.then(OptionalDouble actual) |
|
OptionalIntAssert |
AbstractBDDSoftAssertions.then(OptionalInt actual) |
|
OptionalLongAssert |
AbstractBDDSoftAssertions.then(OptionalLong actual) |
|
<ELEMENT> SpliteratorAssert<ELEMENT> |
AbstractBDDSoftAssertions.then(Spliterator<ELEMENT> actual) |
|
AbstractListAssert<?,List<? extends Double>,Double,ObjectAssert<Double>> |
AbstractBDDSoftAssertions.then(DoubleStream actual) |
|
AbstractListAssert<?,List<? extends Integer>,Integer,ObjectAssert<Integer>> |
AbstractBDDSoftAssertions.then(IntStream actual) |
|
AbstractListAssert<?,List<? extends Long>,Long,ObjectAssert<Long>> |
AbstractBDDSoftAssertions.then(LongStream actual) |
|
<ELEMENT> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> |
AbstractBDDSoftAssertions.then(Stream<? extends ELEMENT> actual) |
|
SELF |
AbstractFileAssert.usingCharset(String charsetName) |
Specifies the name of the charset to use for text-based assertions on the file's contents.
|
SELF |
AbstractFileAssert.usingCharset(Charset charset) |
Specifies the charset to use for text-based assertions on the file's contents.
|
SELF |
AbstractPathAssert.usingCharset(String charsetName) |
Specifies the name of the charset to use for text-based assertions on the path's contents (path must be a readable
file).
|
SELF |
AbstractPathAssert.usingCharset(Charset charset) |
Specifies the charset to use for text-based assertions on the path's contents (path must be a readable file).
|
SELF |
AbstractAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
|
SELF |
AbstractAssert.usingComparator(Comparator<? super ACTUAL> customComparator,
String customComparatorDescription) |
Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
|
SELF |
AbstractBigDecimalAssert.usingComparator(Comparator<? super BigDecimal> customComparator) |
|
SELF |
AbstractBigDecimalAssert.usingComparator(Comparator<? super BigDecimal> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractBigIntegerAssert.usingComparator(Comparator<? super BigInteger> customComparator) |
|
SELF |
AbstractBigIntegerAssert.usingComparator(Comparator<? super BigInteger> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractByteAssert.usingComparator(Comparator<? super Byte> customComparator) |
|
SELF |
AbstractByteAssert.usingComparator(Comparator<? super Byte> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractCharacterAssert.usingComparator(Comparator<? super Character> customComparator) |
|
SELF |
AbstractCharacterAssert.usingComparator(Comparator<? super Character> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractCharSequenceAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
|
SELF |
AbstractCharSequenceAssert.usingComparator(Comparator<? super ACTUAL> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractComparableAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
|
SELF |
AbstractComparableAssert.usingComparator(Comparator<? super ACTUAL> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractDateAssert.usingComparator(Comparator<? super Date> customComparator) |
|
SELF |
AbstractDateAssert.usingComparator(Comparator<? super Date> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractDoubleAssert.usingComparator(Comparator<? super Double> customComparator) |
|
SELF |
AbstractDoubleAssert.usingComparator(Comparator<? super Double> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractFloatAssert.usingComparator(Comparator<? super Float> customComparator) |
|
SELF |
AbstractFloatAssert.usingComparator(Comparator<? super Float> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractIntegerAssert.usingComparator(Comparator<? super Integer> customComparator) |
|
SELF |
AbstractIntegerAssert.usingComparator(Comparator<? super Integer> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractIterableAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
|
SELF |
AbstractIterableAssert.usingComparator(Comparator<? super ACTUAL> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractListAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
|
SELF |
AbstractListAssert.usingComparator(Comparator<? super ACTUAL> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractLongAssert.usingComparator(Comparator<? super Long> customComparator) |
|
SELF |
AbstractLongAssert.usingComparator(Comparator<? super Long> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractMapAssert.usingComparator(Comparator<? super ACTUAL> customComparator) |
|
SELF |
AbstractMapAssert.usingComparator(Comparator<? super ACTUAL> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractShortAssert.usingComparator(Comparator<? super Short> customComparator) |
|
SELF |
AbstractShortAssert.usingComparator(Comparator<? super Short> customComparator,
String customComparatorDescription) |
|
SELF |
AbstractStringAssert.usingComparator(Comparator<? super String> customComparator) |
Use the given custom comparator instead of relying on String natural comparator for the incoming assertions.
|
SELF |
AbstractStringAssert.usingComparator(Comparator<? super String> customComparator,
String customComparatorDescription) |
Use the given custom comparator instead of relying on String natural comparator for the incoming assertions.
|
AtomicIntegerAssert |
AtomicIntegerAssert.usingComparator(Comparator<? super AtomicInteger> customComparator) |
|
AtomicIntegerAssert |
AtomicIntegerAssert.usingComparator(Comparator<? super AtomicInteger> customComparator,
String customComparatorDescription) |
|
AtomicLongAssert |
AtomicLongAssert.usingComparator(Comparator<? super AtomicLong> customComparator) |
|
AtomicLongAssert |
AtomicLongAssert.usingComparator(Comparator<? super AtomicLong> customComparator,
String customComparatorDescription) |
|
<T> SELF |
AbstractIterableAssert.usingComparatorForElementFieldsWithNames(Comparator<T> comparator,
String... elementPropertyOrFieldNames) |
Allows to set a comparator to compare properties or fields of elements with the given names.
|
<C> SELF |
AbstractObjectArrayAssert.usingComparatorForElementFieldsWithNames(Comparator<C> comparator,
String... elementPropertyOrFieldNames) |
Allows to set a comparator to compare properties or fields of elements with the given names.
|
<C> AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.usingComparatorForElementFieldsWithNames(Comparator<C> comparator,
String... elementPropertyOrFieldNames) |
Allows to set a comparator to compare properties or fields of elements with the given names.
|
<T> SELF |
AbstractIterableAssert.usingComparatorForElementFieldsWithType(Comparator<T> comparator,
Class<T> type) |
Allows to set a specific comparator to compare properties or fields of elements with the given type.
|
<C> SELF |
AbstractObjectArrayAssert.usingComparatorForElementFieldsWithType(Comparator<C> comparator,
Class<C> type) |
Allows to set a specific comparator to compare properties or fields of elements with the given type.
|
<C> AtomicReferenceArrayAssert<T> |
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.
|
<T> SELF |
AbstractObjectAssert.usingComparatorForFields(Comparator<T> comparator,
String... propertiesOrFields) |
Allows to set a specific comparator to compare properties or fields with the given names.
|
<T> SELF |
AbstractIterableAssert.usingComparatorForType(Comparator<T> comparator,
Class<T> type) |
Allows to set a specific comparator for the given type of elements or their fields.
|
<C> SELF |
AbstractObjectArrayAssert.usingComparatorForType(Comparator<C> comparator,
Class<C> type) |
Allows to set a specific comparator for the given type of elements or their fields.
|
<T> SELF |
AbstractObjectAssert.usingComparatorForType(Comparator<? super T> comparator,
Class<T> type) |
Allows to set a specific comparator to compare properties or fields with the given type.
|
<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.
|
SELF |
AbstractDoubleArrayAssert.usingComparatorWithPrecision(Double precision) |
|
SELF |
AbstractFloatArrayAssert.usingComparatorWithPrecision(Float precision) |
|
SELF |
AbstractAssert.usingDefaultComparator() |
Revert to standard comparison for the incoming assertion checks.
|
SELF |
AbstractBigDecimalAssert.usingDefaultComparator() |
|
SELF |
AbstractBigIntegerAssert.usingDefaultComparator() |
|
SELF |
AbstractByteAssert.usingDefaultComparator() |
|
SELF |
AbstractCharacterAssert.usingDefaultComparator() |
|
SELF |
AbstractCharSequenceAssert.usingDefaultComparator() |
|
SELF |
AbstractComparableAssert.usingDefaultComparator() |
|
SELF |
AbstractDateAssert.usingDefaultComparator() |
|
SELF |
AbstractDoubleAssert.usingDefaultComparator() |
|
SELF |
AbstractFloatAssert.usingDefaultComparator() |
|
SELF |
AbstractIntegerAssert.usingDefaultComparator() |
|
SELF |
AbstractIterableAssert.usingDefaultComparator() |
|
SELF |
AbstractListAssert.usingDefaultComparator() |
|
SELF |
AbstractLongAssert.usingDefaultComparator() |
|
SELF |
AbstractMapAssert.usingDefaultComparator() |
|
SELF |
AbstractShortAssert.usingDefaultComparator() |
|
SELF |
AbstractStringAssert.usingDefaultComparator() |
|
AtomicIntegerAssert |
AtomicIntegerAssert.usingDefaultComparator() |
|
AtomicLongAssert |
AtomicLongAssert.usingDefaultComparator() |
|
SELF |
AbstractByteArrayAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
AbstractCharArrayAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
AbstractDoubleArrayAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
AbstractFloatArrayAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
AbstractIntArrayAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
AbstractIterableAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
AbstractListAssert.usingDefaultElementComparator() |
|
SELF |
AbstractLongArrayAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
AbstractObjectArrayAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
AbstractShortArrayAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
AtomicIntegerArrayAssert |
AtomicIntegerArrayAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.usingDefaultElementComparator() |
Revert to standard comparison for incoming assertion group element checks.
|
SELF |
AbstractOptionalAssert.usingDefaultValueComparator() |
Revert to standard comparison for incoming assertion Optional value checks.
|
SELF |
AbstractByteArrayAssert.usingElementComparator(Comparator<? super Byte> customComparator) |
Use given custom comparator instead of relying on actual type A equals method to compare group
elements for incoming assertion checks.
|
SELF |
AbstractCharArrayAssert.usingElementComparator(Comparator<? super Character> customComparator) |
Use given custom comparator instead of relying on actual type A equals method to compare group
elements for incoming assertion checks.
|
SELF |
AbstractDoubleArrayAssert.usingElementComparator(Comparator<? super Double> customComparator) |
Use given custom comparator instead of relying on actual type A equals method to compare group
elements for incoming assertion checks.
|
SELF |
AbstractFloatArrayAssert.usingElementComparator(Comparator<? super Float> customComparator) |
Use given custom comparator instead of relying on actual type A equals method to compare group
elements for incoming assertion checks.
|
SELF |
AbstractIntArrayAssert.usingElementComparator(Comparator<? super Integer> customComparator) |
Use given custom comparator instead of relying on actual type A equals method to compare group
elements for incoming assertion checks.
|
SELF |
AbstractIterableAssert.usingElementComparator(Comparator<? super ELEMENT> elementComparator) |
Use given custom comparator instead of relying on actual type A equals method to compare group
elements for incoming assertion checks.
|
SELF |
AbstractListAssert.usingElementComparator(Comparator<? super ELEMENT> customComparator) |
|
SELF |
AbstractLongArrayAssert.usingElementComparator(Comparator<? super Long> customComparator) |
Use given custom comparator instead of relying on actual type A equals method to compare group
elements for incoming assertion checks.
|
SELF |
AbstractObjectArrayAssert.usingElementComparator(Comparator<? super ELEMENT> elementComparator) |
Use given custom comparator instead of relying on actual type A equals method to compare group
elements for incoming assertion checks.
|
SELF |
AbstractShortArrayAssert.usingElementComparator(Comparator<? super Short> customComparator) |
Use given custom comparator instead of relying on actual type A equals method to compare group
elements for incoming assertion checks.
|
AtomicIntegerArrayAssert |
AtomicIntegerArrayAssert.usingElementComparator(Comparator<? super Integer> customComparator) |
Use given custom comparator instead of relying on Integer equals method to compare elements for incoming assertion checks.
|
AtomicLongArrayAssert |
AtomicLongArrayAssert.usingElementComparator(Comparator<? super Long> customComparator) |
Use given custom comparator instead of relying on Long equals method to compare elements for incoming assertion 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.
|
SELF |
AbstractIterableAssert.usingElementComparatorIgnoringFields(String... fields) |
Use field/property by field/property comparison on all fields/properties except the given ones (including inherited
fields/properties) instead of relying on actual type A equals method to compare group elements for
incoming assertion checks.
|
SELF |
AbstractObjectArrayAssert.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 A equals method to compare group elements for
incoming assertion checks.
|
AtomicReferenceArrayAssert<T> |
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 A equals method to compare AtomicReferenceArray elements for
incoming assertion checks.
|
SELF |
AbstractIterableAssert.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 A equals method to compare group elements for
incoming assertion checks.
|
SELF |
AbstractObjectArrayAssert.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 A equals method to compare group elements for
incoming assertion checks.
|
AtomicReferenceArrayAssert<T> |
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 A equals method to compare AtomicReferenceArray elements for
incoming assertion checks.
|
private SELF |
AbstractIterableAssert.usingExtendedByTypesElementComparator(Comparator<Object> elementComparator) |
|
SELF |
AbstractIterableAssert.usingFieldByFieldElementComparator() |
Use field/property by field/property comparison (including inherited fields/properties) instead of relying on
actual type A equals method to compare group elements for incoming assertion checks.
|
SELF |
AbstractObjectArrayAssert.usingFieldByFieldElementComparator() |
Use field/property by field/property comparison (including inherited fields/properties) instead of relying on
actual type A equals method to compare group elements for incoming assertion checks.
|
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.usingFieldByFieldElementComparator() |
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.
|
SELF |
AbstractOptionalAssert.usingFieldByFieldValueComparator() |
Use field/property by field/property comparison (including inherited fields/properties) instead of relying on
actual type A equals method to compare the Optional value's object for incoming assertion
checks.
|
SELF |
AbstractIterableAssert.usingRecursiveFieldByFieldElementComparator() |
Use a recursive field/property by field/property comparison (including inherited fields/properties)
instead of relying on actual type equals method to compare group elements for incoming
assertion checks.
|
SELF |
AbstractObjectArrayAssert.usingRecursiveFieldByFieldElementComparator() |
Use a recursive field/property by field/property comparison (including inherited fields/properties)
instead of relying on actual type A equals method to compare group elements for incoming
assertion checks.
|
AtomicReferenceArrayAssert<T> |
AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparator() |
Use a recursive 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.
|
SELF |
AbstractOptionalAssert.usingValueComparator(Comparator<? super VALUE> customComparator) |
Use given custom comparator instead of relying on actual type A equals method to compare the
Optional value's object for incoming assertion checks.
|
SELF |
RecursiveComparisonAssert.withComparatorForFields(Comparator<?> comparator,
String... fieldLocations) |
Allows to register a specific comparator to compare fields with the given locations.
|
<T> SELF |
RecursiveComparisonAssert.withComparatorForType(Comparator<? super T> comparator,
Class<T> type) |
Allows to register a specific comparator to compare the fields with the given type.
|
SELF |
AbstractDateAssert.withDateFormat(String userCustomDateFormatPattern) |
|
SELF |
AbstractDateAssert.withDateFormat(DateFormat userCustomDateFormat) |
|
SELF |
AbstractDateAssert.withDefaultDateFormatsOnly() |
Remove all registered custom date formats => use only the defaults date formats to parse string as date.
|
SELF |
AbstractAssert.withFailMessage(String newErrorMessage,
Object... args) |
|
SELF |
AbstractIterableAssert.withFailMessage(String newErrorMessage,
Object... args) |
|
SELF |
AbstractListAssert.withFailMessage(String newErrorMessage,
Object... args) |
|
SELF |
AbstractMapAssert.withFailMessage(String newErrorMessage,
Object... args) |
|
SELF |
AbstractAssert.withRepresentation(Representation representation) |
Use the given Representation to describe/represent values in AssertJ error messages.
|
SELF |
RecursiveComparisonAssert.withStrictTypeChecking() |
Makes the recursive comparison to check that actual's type is compatible with expected's type (and do the same for each field).
|
SELF |
AbstractAssert.withThreadDumpOnError() |
In case of an assertion error, a thread dump will be printed to System.err .
|
SELF |
AbstractIterableAssert.withThreadDumpOnError() |
|
SELF |
AbstractListAssert.withThreadDumpOnError() |
|
SELF |
AbstractMapAssert.withThreadDumpOnError() |
|