public interface WithAssertions extends InstanceOfAssertFactories
ARRAY, ARRAY_2D, ATOMIC_BOOLEAN, ATOMIC_INTEGER, ATOMIC_INTEGER_ARRAY, ATOMIC_INTEGER_FIELD_UPDATER, ATOMIC_LONG, ATOMIC_LONG_ARRAY, ATOMIC_LONG_FIELD_UPDATER, ATOMIC_MARKABLE_REFERENCE, ATOMIC_REFERENCE, ATOMIC_REFERENCE_ARRAY, ATOMIC_REFERENCE_FIELD_UPDATER, ATOMIC_STAMPED_REFERENCE, BIG_DECIMAL, BIG_INTEGER, BOOLEAN, BOOLEAN_2D_ARRAY, BOOLEAN_ARRAY, BYTE, BYTE_2D_ARRAY, BYTE_ARRAY, CHAR_2D_ARRAY, CHAR_ARRAY, CHAR_SEQUENCE, CHARACTER, CLASS, COLLECTION, COMPLETABLE_FUTURE, COMPLETION_STAGE, DATE, DOUBLE, DOUBLE_2D_ARRAY, DOUBLE_ARRAY, DOUBLE_PREDICATE, DOUBLE_STREAM, DURATION, FILE, FLOAT, FLOAT_2D_ARRAY, FLOAT_ARRAY, FUTURE, INPUT_STREAM, INSTANT, INT_2D_ARRAY, INT_ARRAY, INT_PREDICATE, INT_STREAM, INTEGER, ITERABLE, ITERATOR, LIST, LOCAL_DATE, LOCAL_DATE_TIME, LOCAL_TIME, LONG, LONG_2D_ARRAY, LONG_ADDER, LONG_ARRAY, LONG_PREDICATE, LONG_STREAM, MAP, MATCHER, OFFSET_DATE_TIME, OFFSET_TIME, OPTIONAL, OPTIONAL_DOUBLE, OPTIONAL_INT, OPTIONAL_LONG, PATH, PERIOD, PREDICATE, SHORT, SHORT_2D_ARRAY, SHORT_ARRAY, SPLITERATOR, STREAM, STRING, STRING_BUFFER, STRING_BUILDER, THROWABLE, URI_TYPE, URL_TYPE, ZONED_DATE_TIME| Modifier and Type | Method and Description |
|---|---|
default <T> Condition<T> |
allOf(Condition<? super T>... conditions)
Creates a new
|
default <T> Condition<T> |
allOf(Iterable<? extends Condition<? super T>> conditions)
Creates a new
|
default <T> Condition<T> |
anyOf(Condition<? super T>... conditions)
Only delegate to
AnyOf.anyOf(Condition...) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use AnyOf if you prefer). |
default <T> Condition<T> |
anyOf(Iterable<? extends Condition<? super T>> conditions)
Creates a new
|
default <T,ASSERT extends AbstractAssert<?,?>> |
as(InstanceOfAssertFactory<T,ASSERT> assertFactory)
A syntax sugar to write fluent assertion with methods having an
InstanceOfAssertFactory parameter. |
default <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
assertThat(ACTUAL actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
Iterable element
in order to perform assertions on it. |
default <T> T |
assertThat(AssertProvider<T> component)
Delegates the creation of the
Assert to the AssertProvider.assertThat() of the given component. |
default AtomicBooleanAssert |
assertThat(AtomicBoolean actual)
Create assertion for
AtomicBoolean. |
default AtomicIntegerAssert |
assertThat(AtomicInteger actual)
Create assertion for
AtomicInteger. |
default AtomicIntegerArrayAssert |
assertThat(AtomicIntegerArray actual)
Create int[] assertion for
AtomicIntegerArray. |
default <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> |
assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)
Create assertion for
AtomicIntegerFieldUpdater. |
default AtomicLongAssert |
assertThat(AtomicLong actual)
Create assertion for
AtomicLong. |
default AtomicLongArrayAssert |
assertThat(AtomicLongArray actual)
Create assertion for
AtomicLongArray. |
default <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> |
assertThat(AtomicLongFieldUpdater<OBJECT> actual)
Create assertion for
AtomicLongFieldUpdater. |
default <VALUE> AtomicMarkableReferenceAssert<VALUE> |
assertThat(AtomicMarkableReference<VALUE> actual)
Create assertion for
AtomicMarkableReference. |
default <VALUE> AtomicReferenceAssert<VALUE> |
assertThat(AtomicReference<VALUE> actual)
Create assertion for
AtomicReference. |
default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> |
assertThat(AtomicReferenceArray<ELEMENT> actual)
Create assertion for
AtomicReferenceArray. |
default <FIELD,OBJECT> |
assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
Create assertion for
AtomicReferenceFieldUpdater. |
default <VALUE> AtomicStampedReferenceAssert<VALUE> |
assertThat(AtomicStampedReference<VALUE> actual)
Create assertion for
AtomicStampedReference. |
default AbstractBigDecimalAssert<?> |
assertThat(BigDecimal actual)
Creates a new instance of
|
default AbstractBigIntegerAssert<?> |
assertThat(BigInteger actual)
Creates a new instance of
|
default AbstractBooleanAssert<?> |
assertThat(boolean actual)
Creates a new instance of
|
default AbstractBooleanAssert<?> |
assertThat(Boolean actual)
Creates a new instance of
|
default AbstractBooleanArrayAssert<?> |
assertThat(boolean[] actual)
Creates a new instance of
|
default Boolean2DArrayAssert |
assertThat(boolean[][] actual)
Creates a new instance of
|
default AbstractByteAssert<?> |
assertThat(byte actual)
Creates a new instance of
|
default AbstractByteAssert<?> |
assertThat(Byte actual)
Creates a new instance of
|
default AbstractByteArrayAssert<?> |
assertThat(byte[] actual)
Creates a new instance of
|
default Byte2DArrayAssert |
assertThat(byte[][] actual)
Creates a new instance of
|
default AbstractCharacterAssert<?> |
assertThat(char actual)
Creates a new instance of
|
default AbstractCharArrayAssert<?> |
assertThat(char[] actual)
Creates a new instance of
|
default Char2DArrayAssert |
assertThat(char[][] actual)
Creates a new instance of
|
default AbstractCharacterAssert<?> |
assertThat(Character actual)
Creates a new instance of
|
default AbstractCharSequenceAssert<?,? extends CharSequence> |
assertThat(CharSequence actual)
Creates a new instance of
|
default ClassAssert |
assertThat(Class<?> actual)
Creates a new instance of
|
default <E> AbstractCollectionAssert<?,Collection<? extends E>,E,ObjectAssert<E>> |
assertThat(Collection<? extends E> actual)
Creates a new instance of
|
default <RESULT> CompletableFutureAssert<RESULT> |
assertThat(CompletableFuture<RESULT> future)
Create assertion for
CompletableFuture. |
default <RESULT> CompletableFutureAssert<RESULT> |
assertThat(CompletionStage<RESULT> completionStage)
Create assertion for
CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert. |
default AbstractDateAssert<?> |
assertThat(Date actual)
Creates a new instance of
|
default AbstractDoubleAssert<?> |
assertThat(double actual)
Creates a new instance of
|
default AbstractDoubleAssert<?> |
assertThat(Double actual)
Creates a new instance of
|
default AbstractDoubleArrayAssert<?> |
assertThat(double[] actual)
Creates a new instance of
|
default Double2DArrayAssert |
assertThat(double[][] actual)
Creates a new instance of
|
default DoublePredicateAssert |
assertThat(DoublePredicate actual)
Create assertion for
DoublePredicate. |
default ListAssert<Double> |
assertThat(DoubleStream actual)
Creates a new instance of
DoubleStream. |
default AbstractDurationAssert<?> |
assertThat(Duration actual)
Creates a new instance of
|
default AbstractFileAssert<?> |
assertThat(File actual)
Creates a new instance of
|
default AbstractFloatAssert<?> |
assertThat(float actual)
Creates a new instance of
|
default AbstractFloatAssert<?> |
assertThat(Float actual)
Creates a new instance of
|
default AbstractFloatArrayAssert<?> |
assertThat(float[] actual)
Creates a new instance of
|
default Float2DArrayAssert |
assertThat(float[][] actual)
Creates a new instance of
|
default <RESULT> FutureAssert<RESULT> |
assertThat(Future<RESULT> actual)
Create assertion for
Future. |
default AbstractInputStreamAssert<?,? extends InputStream> |
assertThat(InputStream actual)
Creates a new instance of
|
default AbstractInstantAssert<?> |
assertThat(Instant actual)
Creates a new instance of
|
default AbstractIntegerAssert<?> |
assertThat(int actual)
Creates a new instance of
|
default AbstractIntArrayAssert<?> |
assertThat(int[] actual)
Creates a new instance of
|
default Int2DArrayAssert |
assertThat(int[][] actual)
Creates a new instance of
|
default AbstractIntegerAssert<?> |
assertThat(Integer actual)
Creates a new instance of
|
default IntPredicateAssert |
assertThat(IntPredicate actual)
Create assertion for
IntPredicate. |
default ListAssert<Integer> |
assertThat(IntStream actual)
Creates a new instance of
IntStream. |
default <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
assertThat(Iterable<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
Iterable element
in order to perform assertions on it. |
default <T> IterableAssert<T> |
assertThat(Iterable<? extends T> actual)
Creates a new instance of
|
default <T> IteratorAssert<T> |
assertThat(Iterator<? extends T> actual)
Creates a new instance of
|
default <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
assertThat(List<? extends ELEMENT> actual,
AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
Creates a new instance of
List element
in order to perform assertions on it. |
default <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> |
assertThat(List<? extends ELEMENT> actual,
Class<ELEMENT_ASSERT> assertClass)
Creates a new instance of
List element
in order to perform assertions on it. |
default <T> ListAssert<T> |
assertThat(List<? extends T> actual)
Creates a new instance of
|
default AbstractLocalDateAssert<?> |
assertThat(LocalDate localDate)
Creates a new instance of
|
default AbstractLocalDateTimeAssert<?> |
assertThat(LocalDateTime localDateTime)
Creates a new instance of
|
default AbstractLocalTimeAssert<?> |
assertThat(LocalTime localTime)
Creates a new instance of
|
default AbstractLongAssert<?> |
assertThat(long actual)
Creates a new instance of
|
default AbstractLongAssert<?> |
assertThat(Long actual)
Creates a new instance of
|
default AbstractLongArrayAssert<?> |
assertThat(long[] actual)
Creates a new instance of
|
default Long2DArrayAssert |
assertThat(long[][] actual)
Creates a new instance of
|
default LongAdderAssert |
assertThat(LongAdder actual)
Create assertion for
LongAdder. |
default LongPredicateAssert |
assertThat(LongPredicate actual)
Create assertion for
LongPredicate. |
default ListAssert<Long> |
assertThat(LongStream actual)
Creates a new instance of
LongStream. |
default <K,V> MapAssert<K,V> |
assertThat(Map<K,V> actual)
Creates a new instance of
|
default MatcherAssert |
assertThat(Matcher matcher)
Create assertion for
Matcher |
default AbstractOffsetDateTimeAssert<?> |
assertThat(OffsetDateTime offsetDateTime)
Creates a new instance of
|
default AbstractOffsetTimeAssert<?> |
assertThat(OffsetTime offsetTime)
Creates a new instance of
|
default <VALUE> OptionalAssert<VALUE> |
assertThat(Optional<VALUE> optional)
Create assertion for
Optional. |
default OptionalDoubleAssert |
assertThat(OptionalDouble optional)
Create assertion for
OptionalDouble. |
default OptionalIntAssert |
assertThat(OptionalInt optional)
Create assertion for
OptionalInt. |
default OptionalLongAssert |
assertThat(OptionalLong optional)
Create assertion for
OptionalLong. |
default AbstractPathAssert<?> |
assertThat(Path actual)
Creates a new instance of
PathAssert |
default AbstractPeriodAssert<?> |
assertThat(Period actual)
Creates a new instance of
|
default <T> PredicateAssert<T> |
assertThat(Predicate<T> actual)
Create assertion for
Predicate. |
default AbstractShortAssert<?> |
assertThat(short actual)
Creates a new instance of
|
default AbstractShortAssert<?> |
assertThat(Short actual)
Creates a new instance of
|
default AbstractShortArrayAssert<?> |
assertThat(short[] actual)
Creates a new instance of
|
default Short2DArrayAssert |
assertThat(short[][] actual)
Creates a new instance of
|
default <ELEMENT> SpliteratorAssert<ELEMENT> |
assertThat(Spliterator<ELEMENT> actual)
Creates a new instance of
|
default <ELEMENT> ListAssert<ELEMENT> |
assertThat(Stream<? extends ELEMENT> actual)
Creates a new instance of
Stream. |
default AbstractStringAssert<?> |
assertThat(String actual)
Creates a new instance of
|
default AbstractCharSequenceAssert<?,? extends CharSequence> |
assertThat(StringBuffer actual)
Creates a new instance of
StringBuffer. |
default AbstractCharSequenceAssert<?,? extends CharSequence> |
assertThat(StringBuilder actual)
Creates a new instance of
StringBuilder. |
default <T> ObjectAssert<T> |
assertThat(T actual)
Creates a new instance of
|
default <T extends Comparable<? super T>> |
assertThat(T actual)
Creates a new instance of
|
default <T extends Throwable> |
assertThat(T actual)
Creates a new instance of
|
default <T extends AssertDelegateTarget> |
assertThat(T assertion)
Returns the given assertion.
|
default <T> ObjectArrayAssert<T> |
assertThat(T[] actual)
Creates a new instance of
|
default <T> Object2DArrayAssert<T> |
assertThat(T[][] actual)
Creates a new instance of
|
default AbstractUriAssert<?> |
assertThat(URI actual)
Creates a new instance of
|
default AbstractUrlAssert<?> |
assertThat(URL actual)
Creates a new instance of
|
default AbstractZonedDateTimeAssert<?> |
assertThat(ZonedDateTime actual)
Creates a new instance of
|
default AbstractThrowableAssert<?,? extends Throwable> |
assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Allows to capture and then assert on a
Throwable more easily when used with Java 8 lambdas. |
default <E> AbstractCollectionAssert<?,Collection<? extends E>,E,ObjectAssert<E>> |
assertThatCollection(Collection<? extends E> actual)
Creates a new instance of
|
default <T> AbstractUniversalComparableAssert<?,T> |
assertThatComparable(Comparable<T> actual)
Creates a new instance of
|
default ThrowableTypeAssert<Exception> |
assertThatException()
Alias for
assertThatExceptionOfType(Class) for Exception. |
default <T extends Throwable> |
assertThatExceptionOfType(Class<? extends T> exceptionType)
Entry point to check that an exception of type T is thrown by a given
throwingCallable
which allows to chain assertions on the thrown exception. |
default ThrowableTypeAssert<IllegalArgumentException> |
assertThatIllegalArgumentException()
Alias for
assertThatExceptionOfType(Class) for IllegalArgumentException. |
default ThrowableTypeAssert<IllegalStateException> |
assertThatIllegalStateException()
Alias for
assertThatExceptionOfType(Class) for IllegalStateException. |
default ThrowableTypeAssert<IndexOutOfBoundsException> |
assertThatIndexOutOfBoundsException()
Alias for
assertThatExceptionOfType(Class) for IndexOutOfBoundsException. |
default ThrowableTypeAssert<IOException> |
assertThatIOException()
Alias for
assertThatExceptionOfType(Class) for IOException. |
default <ELEMENT> IterableAssert<ELEMENT> |
assertThatIterable(Iterable<? extends ELEMENT> actual)
Creates a new instance of
|
default <ELEMENT> IteratorAssert<ELEMENT> |
assertThatIterator(Iterator<? extends ELEMENT> actual)
Creates a new instance of
|
default <ELEMENT> ListAssert<ELEMENT> |
assertThatList(List<? extends ELEMENT> actual)
Creates a new instance of
|
default NotThrownAssert |
assertThatNoException()
Entry point to check that no exception of any type is thrown by a given
throwingCallable. |
default ThrowableTypeAssert<NullPointerException> |
assertThatNullPointerException()
Alias for
assertThatExceptionOfType(Class) for NullPointerException. |
default <T> ObjectAssert<T> |
assertThatObject(T actual)
Creates a new instance of
|
default AbstractPathAssert<?> |
assertThatPath(Path actual)
Creates a new instance of
PathAssert |
default <T> PredicateAssert<T> |
assertThatPredicate(Predicate<T> actual)
Create assertion for
Predicate. |
default ThrowableTypeAssert<ReflectiveOperationException> |
assertThatReflectiveOperationException()
Alias for
assertThatExceptionOfType(Class) for ReflectiveOperationException. |
default ThrowableTypeAssert<RuntimeException> |
assertThatRuntimeException()
Alias for
assertThatExceptionOfType(Class) for RuntimeException. |
default <ELEMENT> ListAssert<ELEMENT> |
assertThatStream(Stream<? extends ELEMENT> actual)
Creates a new instance of
Stream. |
default AbstractThrowableAssert<?,? extends Throwable> |
assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to capture and then assert on a
Throwable (easier done with lambdas). |
default AbstractThrowableAssert<?,? extends Throwable> |
assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable,
String description,
Object... args)
Allows to capture and then assert on a
Throwable like assertThatThrownBy(ThrowingCallable) but this method
let you set the assertion description the same way you do with as(String, Object...). |
default <T> ObjectAssert<T> |
assertWith(T actual,
Consumer<T>... requirements)
Uses the given instance as the instance under test for all the assertions expressed as the passed
Consumer. |
default Index |
atIndex(int index)
Only delegate to
Index.atIndex(int) so that Assertions offers a full feature entry point to all AssertJ
features (but you can use Index if you prefer). |
default Offset<BigDecimal> |
byLessThan(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
default Offset<BigInteger> |
byLessThan(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
default Offset<Byte> |
byLessThan(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
default Offset<Double> |
byLessThan(Double value)
Alias for
offset(Double) to use with isCloseTo assertions. |
default Offset<Float> |
byLessThan(Float value)
Alias for
offset(Float) to use with isCloseTo assertions. |
default Offset<Integer> |
byLessThan(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
default Offset<Long> |
byLessThan(Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
default TemporalUnitOffset |
byLessThan(long value,
TemporalUnit unit)
Assertions entry point for
TemporalUnitOffset with strict less than condition
to use with isCloseTo temporal assertions. |
default Offset<Short> |
byLessThan(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
default Exception |
catchException(ThrowableAssert.ThrowingCallable shouldRaiseException)
Allows catching an instance of
Exception. |
default IllegalArgumentException |
catchIllegalArgumentException(ThrowableAssert.ThrowingCallable shouldRaiseIllegalArgumentException)
Allows catching an instance of
IllegalArgumentException. |
default IllegalStateException |
catchIllegalStateException(ThrowableAssert.ThrowingCallable shouldRaiseIllegalStateException)
Allows catching an instance of
IllegalStateException. |
default IndexOutOfBoundsException |
catchIndexOutOfBoundsException(ThrowableAssert.ThrowingCallable shouldRaiseIndexOutOfBoundException)
Allows catching an instance of
IndexOutOfBoundsException. |
default IOException |
catchIOException(ThrowableAssert.ThrowingCallable shouldRaiseIOException)
Allows catching an instance of
IOException. |
default NullPointerException |
catchNullPointerException(ThrowableAssert.ThrowingCallable shouldRaiseNullPointerException)
Allows catching an instance of
NullPointerException. |
default ReflectiveOperationException |
catchReflectiveOperationException(ThrowableAssert.ThrowingCallable shouldRaiseReflectiveOperationException)
Allows catching an instance of
ReflectiveOperationException. |
default RuntimeException |
catchRuntimeException(ThrowableAssert.ThrowingCallable shouldRaiseRuntimeException)
Allows catching an instance of
RuntimeException. |
default Throwable |
catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Allows to catch an
Throwable more easily when used with Java 8 lambdas. |
default <THROWABLE extends Throwable> |
catchThrowableOfType(ThrowableAssert.ThrowingCallable shouldRaiseThrowable,
Class<THROWABLE> type)
Allows catching a
Throwable of a specific type. |
default String |
contentOf(File file)
Loads the text content of a file with the default character set, so that it can be passed to
assertThat(String). |
default String |
contentOf(File file,
Charset charset)
Loads the text content of a file, so that it can be passed to
assertThat(String). |
default String |
contentOf(File file,
String charsetName)
Loads the text content of a file, so that it can be passed to
assertThat(String). |
default String |
contentOf(URL url)
Loads the text content of a URL with the default character set, so that it can be passed to
assertThat(String). |
default String |
contentOf(URL url,
Charset charset)
Loads the text content of a URL, so that it can be passed to
assertThat(String). |
default String |
contentOf(URL url,
String charsetName)
Loads the text content of a URL, so that it can be passed to
assertThat(String). |
default <T> DoesNotHave<T> |
doesNotHave(Condition<? super T> condition)
Creates a new
|
default <K,V> MapEntry<K,V> |
entry(K key,
V value)
Only delegate to
MapEntry.entry(Object, Object) so that Assertions offers a full feature entry point to
all
AssertJ features (but you can use MapEntry if you prefer). |
default Properties<Object> |
extractProperty(String propertyName)
Only delegate to
Properties.extractProperty(String) so that Assertions offers a full feature entry point
to
all AssertJ features (but you can use Properties if you prefer). |
default <T> Properties<T> |
extractProperty(String propertyName,
Class<T> propertyType)
Only delegate to
Properties.extractProperty(String) so that Assertions offers a full feature entry point
to
all AssertJ features (but you can use Properties if you prefer). |
default <T> T |
fail(String failureMessage)
Throws an
AssertionError with the given message. |
default <T> T |
fail(String failureMessage,
Object... args)
Throws an
AssertionError with the given message built as String.format(String, Object...). |
default <T> T |
fail(String failureMessage,
Throwable realCause)
Throws an
AssertionError with the given message and with the Throwable that caused the failure. |
default <T> T |
failBecauseExceptionWasNotThrown(Class<? extends Throwable> throwableClass)
Throws an
AssertionError with a message explaining that a Throwable of given class was expected to be thrown
but had not been. |
default <E> Filters<E> |
filter(E[] array)
Only delegate to
Filters.filter(Object[]) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use Filters if you prefer). |
default <E> Filters<E> |
filter(Iterable<E> iterableToFilter)
Only delegate to
Filters.filter(Object[]) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use Filters if you prefer). |
default <F,T> Function<F,T> |
from(Function<F,T> extractor)
A syntax sugar to write fluent assertion using
AbstractObjectAssert.returns(Object, Function) and
AbstractObjectAssert.doesNotReturn(Object, Function). |
default InFilter |
in(Object... values)
Create a
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches one of the given values. |
default List<String> |
linesOf(File file)
Loads the text content of a file into a list of strings with the default charset, each string corresponding to a
line.
|
default List<String> |
linesOf(File file,
Charset charset)
Loads the text content of a file into a list of strings, each string corresponding to a line.
|
default List<String> |
linesOf(File file,
String charsetName)
Loads the text content of a file into a list of strings, each string corresponding to a line.
|
default List<String> |
linesOf(Path path)
Loads the text content of a file at a given path into a list of strings with the default charset, each string corresponding to a
line.
|
default List<String> |
linesOf(Path path,
Charset charset)
Loads the text content of a file at a given path into a list of strings, each string corresponding to a line.
|
default List<String> |
linesOf(Path path,
String charsetName)
Loads the text content of a file at a given path into a list of strings, each string corresponding to a line.
|
default List<String> |
linesOf(URL url)
Loads the text content of a URL into a list of strings with the default charset, each string corresponding to a
line.
|
default List<String> |
linesOf(URL url,
Charset charset)
Loads the text content of a URL into a list of strings, each string corresponding to a line.
|
default List<String> |
linesOf(URL url,
String charsetName)
Loads the text content of a URL into a list of strings, each string corresponding to a line.
|
default <T> Not<T> |
not(Condition<? super T> condition)
Creates a new
|
default NotFilter |
not(Object valueNotToMatch)
Create a
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches does not match the given value. |
default NotInFilter |
notIn(Object... valuesNotToMatch)
Create a
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches does not match any of the given values. |
default Offset<Double> |
offset(Double value)
Assertions entry point for double
Offset. |
default Offset<Float> |
offset(Float value)
Assertions entry point for float
Offset. |
default void |
registerCustomDateFormat(DateFormat userCustomDateFormat)
Add the given date format to the ones used to parse date String in String based Date assertions like
AbstractDateAssert.isEqualTo(String). |
default void |
registerCustomDateFormat(String userCustomDateFormatPattern)
Add the given date format to the ones used to parse date String in String based Date assertions like
AbstractDateAssert.isEqualTo(String). |
default <T> void |
registerFormatterForType(Class<T> type,
Function<T,String> formatter)
Assertions error messages uses a
Representation to format the different types involved, using this method
you can control the formatting of a given type by providing a specific formatter. |
default void |
setAllowComparingPrivateFields(boolean allowComparingPrivateFields)
Globally sets whether the use of private fields is allowed for comparison.
|
default void |
setAllowExtractingPrivateFields(boolean allowExtractingPrivateFields)
Globally sets whether
|
static void |
setDescriptionConsumer(Consumer<Description> descriptionConsumer)
All assertions description will be consumed by the given
Consumer<Description> allowing for example to record them in a file. |
default void |
setExtractBareNamePropertyMethods(boolean barenamePropertyMethods)
Globally sets whether the extractor considers bare-named property methods like
String name(). |
default void |
setLenientDateParsing(boolean value)
Instead of using default strict date/time parsing, it is possible to use lenient parsing mode for default date
formats parser to interpret inputs that do not precisely match supported date formats (lenient parsing).
|
default void |
setMaxElementsForPrinting(int maxElementsForPrinting)
Sets the maximum number of elements to display in error messages for iterables, arrays and map .
|
default void |
setMaxLengthForSingleLineDescription(int maxLengthForSingleLineDescription)
In error messages, sets the threshold when iterable/array formatting will on one line (if their String description
is less than this parameter) or it will be formatted with one element per line.
|
default void |
setMaxStackTraceElementsDisplayed(int maxStackTraceElementsDisplayed)
Sets how many stacktrace elements are included in
Throwable representation (by default this set to 3). |
static void |
setPrintAssertionsDescription(boolean printAssertionsDescription)
Enable/disable printing assertions description to the console (disabled by default).
|
default void |
setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)
Sets whether we remove elements related to AssertJ from assertion error stack trace.
|
default <T> T |
shouldHaveThrown(Class<? extends Throwable> throwableClass)
Throws an
AssertionError with a message explaining that a Throwable of given class was expected to be thrown
but had not been. |
default Tuple |
tuple(Object... values)
Utility method to build nicely a
Tuple when working with AbstractIterableAssert.extracting(String...) or
AbstractObjectArrayAssert.extracting(String...) |
default void |
useDefaultDateFormatsOnly()
Remove all registered custom date formats => use only the defaults date formats to parse string as date.
|
default void |
useDefaultRepresentation()
Fallback to use
StandardRepresentation to revert the effect of calling useRepresentation(Representation). |
default void |
useRepresentation(Representation customRepresentation)
Register a
Representation that will be used in all following assertions. |
default Offset<BigDecimal> |
within(BigDecimal value)
Assertions entry point for BigDecimal
Offset to use with isCloseTo assertions. |
default Offset<BigInteger> |
within(BigInteger value)
Assertions entry point for BigInteger
Offset to use with isCloseTo assertions. |
default Offset<Byte> |
within(Byte value)
Assertions entry point for Byte
Offset to use with isCloseTo assertions. |
default Offset<Double> |
within(Double value)
Alias for
offset(Double) to use with isCloseTo assertions. |
default Offset<Float> |
within(Float value)
Alias for
offset(Float) to use with isCloseTo assertions. |
default Offset<Integer> |
within(Integer value)
Assertions entry point for Integer
Offset to use with isCloseTo assertions. |
default Offset<Long> |
within(Long value)
Assertions entry point for Long
Offset to use with isCloseTo assertions. |
default TemporalUnitOffset |
within(long value,
TemporalUnit unit)
Assertions entry point for
TemporalUnitOffset with with less than or equal condition
to use with isCloseTo temporal assertions. |
default Offset<Short> |
within(Short value)
Assertions entry point for Short
Offset to use with isCloseTo assertions. |
default Percentage |
withinPercentage(Double value)
Assertions entry point for Double
Percentage to use with isCloseTo assertions for
percentages. |
default Percentage |
withinPercentage(Integer value)
Assertions entry point for Integer
Percentage to use with isCloseTo assertions for
percentages. |
default Percentage |
withinPercentage(Long value)
Assertions entry point for Long
Percentage to use with isCloseTo assertions for
percentages. |
default Duration |
withMarginOf(Duration allowedDifference)
Syntactic sugar method to use with
AbstractDurationAssert.isCloseTo(Duration, Duration) assertion. |
default Offset<Double> |
withPrecision(Double value)
Assertions entry point for double
Offset. |
default Offset<Float> |
withPrecision(Float value)
Assertions entry point for float
Offset. |
array, array2D, atomicIntegerFieldUpdater, atomicLongFieldUpdater, atomicMarkableReference, atomicReference, atomicReferenceArray, atomicReferenceFieldUpdater, atomicStampedReference, collection, comparable, completableFuture, completionStage, future, iterable, iterator, list, map, optional, predicate, spliterator, stream, throwable, typedefault Offset<Float> offset(Float value)
Offset.
Typical usage :
assertThat(8.2f).isCloseTo(8.0f, offset(0.2f));value - the allowed offsetOffset.default Offset<Double> offset(Double value)
Offset.
Typical usage :
assertThat(8.1).isEqualTo(8.0, offset(0.1));value - the allowed offsetOffset.default <K,V> MapEntry<K,V> entry(K key, V value)
MapEntry.entry(Object, Object) so that Assertions offers a full feature entry point to
all
AssertJ features (but you can use MapEntry if you prefer).
Typical usage is to call entry in MapAssert contains assertion, see examples below :
Map<Ring, TolkienCharacter> ringBearers = ... // init omitted
assertThat(ringBearers).contains(entry(oneRing, frodo), entry(nenya, galadriel));K - the type of keys in the map.V - the type of values in the map.key - the key of the entry to create.value - the value of the entry to create.MapEntry.default <T> T fail(String failureMessage)
AssertionError with the given message.T - dummy return value typefailureMessage - error message.doSomething(optional.orElseGet(() -> fail("boom")));.AssertionError - with the given message.default <T> T fail(String failureMessage, Object... args)
AssertionError with the given message built as String.format(String, Object...).T - dummy return value typefailureMessage - error message.args - Arguments referenced by the format specifiers in the format string.doSomething(optional.orElseGet(() -> fail("b%s", "oom")));.AssertionError - with the given built message.default <T> T fail(String failureMessage, Throwable realCause)
AssertionError with the given message and with the Throwable that caused the failure.T - dummy return value typefailureMessage - the description of the failed assertion. It can be null.realCause - cause of the error.doSomething(optional.orElseGet(() -> fail("boom", cause)));.AssertionError - with the given message and with the Throwable that caused the failure.default <T> Not<T> not(Condition<? super T> condition)
NotT - the type of object the given condition accept.condition - the condition to inverse.default <T> Condition<T> allOf(Iterable<? extends Condition<? super T>> conditions)
AllOfT - the type of object the given condition accept.conditions - the conditions to evaluate.AllOf.NullPointerException - if the given iterable is null.NullPointerException - if any of the elements in the given iterable is null.default <T> Condition<T> allOf(Condition<? super T>... conditions)
AllOfT - the type of object the given condition accept.conditions - the conditions to evaluate.AllOf.NullPointerException - if the given array is null.NullPointerException - if any of the elements in the given array is null.default <T> ObjectArrayAssert<T> assertThat(T[] actual)
ObjectArrayAssertT - the actual's elements type.actual - the actual value.default <T> Object2DArrayAssert<T> assertThat(T[][] actual)
Object2DArrayAssertT - the actual's elements type.actual - the actual value.default <T extends AssertDelegateTarget> T assertThat(T assertion)
assertThat.
Consider for example the following MyButton and MyButtonAssert classes:
public class MyButton extends JButton {
private boolean blinking;
public boolean isBlinking() { return this.blinking; }
public void setBlinking(boolean blink) { this.blinking = blink; }
}
private static class MyButtonAssert implements AssertDelegateTarget {
private MyButton button;
MyButtonAssert(MyButton button) { this.button = button; }
void isBlinking() {
// standard assertion from core Assertions.assertThat
assertThat(button.isBlinking()).isTrue();
}
void isNotBlinking() {
// standard assertion from core Assertions.assertThat
assertThat(button.isBlinking()).isFalse();
}
}assertThat(buttonAssert).isBlinking();
instead of buttonAssert.isBlinking(); to have easier to read assertions:
@Test
public void AssertDelegateTarget_example() {
MyButton button = new MyButton();
MyButtonAssert buttonAssert = new MyButtonAssert(button);
// you can encapsulate MyButtonAssert assertions methods within assertThat
assertThat(buttonAssert).isNotBlinking(); // same as : buttonAssert.isNotBlinking();
button.setBlinking(true);
assertThat(buttonAssert).isBlinking(); // same as : buttonAssert.isBlinking();
}T - the generic type of the user-defined assert.assertion - the assertion to return.default <K,V> MapAssert<K,V> assertThat(Map<K,V> actual)
MapAssert
Returned type is MapAssert as it overrides method to annotate them with SafeVarargs avoiding
annoying warnings.
K - the type of keys in the map.V - the type of values in the map.actual - the actual value.default AbstractShortAssert<?> assertThat(short actual)
ShortAssertactual - the actual value.default AbstractLongAssert<?> assertThat(long actual)
LongAssertactual - the actual value.default AbstractLongAssert<?> assertThat(Long actual)
LongAssertactual - the actual value.default AbstractLongArrayAssert<?> assertThat(long[] actual)
LongArrayAssertactual - the actual value.default Long2DArrayAssert assertThat(long[][] actual)
Long2DArrayAssertactual - the actual value.default <T> ObjectAssert<T> assertThat(T actual)
ObjectAssertT - the type of the actual value.actual - the actual value.default AbstractStringAssert<?> assertThat(String actual)
CharSequenceAssertfrom a Stringactual - the actual value.default AbstractDateAssert<?> assertThat(Date actual)
DateAssertactual - the actual value.default <T extends Throwable> AbstractThrowableAssert<?,T> assertThat(T actual)
ThrowableAssertT - the type of the actual throwable.actual - the actual value.ThrowableAssert.default AbstractBigDecimalAssert<?> assertThat(BigDecimal actual)
BigDecimalAssertactual - the actual value.default AbstractBigIntegerAssert<?> assertThat(BigInteger actual)
BigIntegerAssertactual - the actual value.default AtomicBooleanAssert assertThat(AtomicBoolean actual)
AtomicBoolean.actual - the actual value.default AtomicIntegerAssert assertThat(AtomicInteger actual)
AtomicInteger.actual - the actual value.default AtomicIntegerArrayAssert assertThat(AtomicIntegerArray actual)
AtomicIntegerArray.actual - the actual value.default <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> assertThat(AtomicIntegerFieldUpdater<OBJECT> actual)
AtomicIntegerFieldUpdater.OBJECT - the type of the object holding the updatable field.actual - the actual value.default LongAdderAssert assertThat(LongAdder actual)
LongAdder.actual - the actual value.default AtomicLongAssert assertThat(AtomicLong actual)
AtomicLong.actual - the actual value.default AtomicLongArrayAssert assertThat(AtomicLongArray actual)
AtomicLongArray.actual - the actual value.default <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> assertThat(AtomicLongFieldUpdater<OBJECT> actual)
AtomicLongFieldUpdater.OBJECT - the type of the object holding the updatable field.actual - the actual value.default <VALUE> AtomicReferenceAssert<VALUE> assertThat(AtomicReference<VALUE> actual)
AtomicReference.VALUE - the type of the value contained in the AtomicReference.actual - the actual value.default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> assertThat(AtomicReferenceArray<ELEMENT> actual)
AtomicReferenceArray.ELEMENT - the type of the value contained in the AtomicReferenceArray.actual - the actual value.default <FIELD,OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> assertThat(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)
AtomicReferenceFieldUpdater.FIELD - the type of the field which gets updated by the AtomicReferenceFieldUpdater.OBJECT - the type of the object holding the updatable field.actual - the actual value.default <VALUE> AtomicMarkableReferenceAssert<VALUE> assertThat(AtomicMarkableReference<VALUE> actual)
AtomicMarkableReference.VALUE - the type of the value contained in the AtomicMarkableReference.actual - the actual value.default <VALUE> AtomicStampedReferenceAssert<VALUE> assertThat(AtomicStampedReference<VALUE> actual)
AtomicStampedReference.VALUE - the type of the value contained in the AtomicStampedReference.actual - the actual value.default AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(CharSequence actual)
CharSequenceAssertactual - the actual value.default AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(StringBuilder actual)
CharSequenceAssertStringBuilder.actual - the actual value.default AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(StringBuffer actual)
CharSequenceAssertStringBuffer.actual - the actual value.default AbstractShortArrayAssert<?> assertThat(short[] actual)
ShortArrayAssertactual - the actual value.default Short2DArrayAssert assertThat(short[][] actual)
Short2DArrayAssertactual - the actual value.default AbstractShortAssert<?> assertThat(Short actual)
ShortAssertactual - the actual value.default ClassAssert assertThat(Class<?> actual)
ClassAssertactual - the actual value.default AbstractCharacterAssert<?> assertThat(Character actual)
CharacterAssertactual - the actual value.default AbstractCharArrayAssert<?> assertThat(char[] actual)
CharArrayAssertactual - the actual value.default Char2DArrayAssert assertThat(char[][] actual)
Char2DArrayAssertactual - the actual value.default AbstractCharacterAssert<?> assertThat(char actual)
CharacterAssertactual - the actual value.default <T extends Comparable<? super T>> AbstractComparableAssert<?,T> assertThat(T actual)
GenericComparableAssertT - the type of actual.actual - the actual value.default <T> AbstractUniversalComparableAssert<?,T> assertThatComparable(Comparable<T> actual)
UniversalComparableAssert
Use this over assertThat(Comparable) in case of ambiguous method resolution when the object under test
implements several interfaces Assertj provides assertThat for.
T - the type of actual.actual - the actual value.default <T> IterableAssert<T> assertThat(Iterable<? extends T> actual)
IterableAssertT - the type of elements.actual - the actual value.default <ELEMENT> IterableAssert<ELEMENT> assertThatIterable(Iterable<? extends ELEMENT> actual)
IterableAssert
Use this over assertThat(Iterable) in case of ambiguous method resolution when the object under test
implements several interfaces Assertj provides assertThat for.
ELEMENT - the type of elements.actual - the actual value.default <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(Iterable<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
FactoryBasedNavigableIterableAssertIterable element
in order to perform assertions on it.
Navigational methods provided:
The available assertions after navigating to an element depend on the ELEMENT_ASSERT parameter of the given
AssertFactory<ELEMENT, ELEMENT_ASSERT> (AssertJ can't figure it out because of Java type erasure).
Example with String element assertions:
Iterable<String> hobbits = newHashSet("frodo", "sam", "pippin");
// build an AssertFactory for StringAssert (much nicer with Java 8 lambdas)
AssertFactory<String, StringAssert> stringAssertFactory = new AssertFactory<String, StringAssert>() {
@Override
public StringAssert createAssert(String string) {
return new StringAssert(string);
}
};
// assertion succeeds with String assertions chained after first()
assertThat(hobbits, stringAssertFactory).first()
.startsWith("fro")
.endsWith("do");ACTUAL - The actual typeELEMENT - The actual elements typeELEMENT_ASSERT - The actual elements AbstractAssert typeactual - the actual value.assertFactory - the factory used to create the elements assert instance.default <T> IteratorAssert<T> assertThat(Iterator<? extends T> actual)
IteratorAssert
Breaking change in version 3.12.0: this method does not return anymore an IterableAssert but an IteratorAssert.
In order to access assertions from IterableAssert, use AbstractIteratorAssert.toIterable().
IteratorAssert instances have limited assertions because it does not consume iterator's elements.
Examples:
Iterator<String> bestBasketBallPlayers = getBestBasketBallPlayers();
assertThat(bestBasketBallPlayers).hasNext() // Iterator assertion
.toIterable() // switch to Iterable assertions
.contains("Jordan", "Magic", "Lebron"); // Iterable assertion T - the type of elements.actual - the actual value.default <ELEMENT> IteratorAssert<ELEMENT> assertThatIterator(Iterator<? extends ELEMENT> actual)
IteratorAssert
Use this over assertThat(Iterator) in case of ambiguous method resolution when the object under test
implements several interfaces Assertj provides assertThat for.
ELEMENT - the type of elements.actual - the actual value.default <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(ACTUAL actual, Class<ELEMENT_ASSERT> assertClass)
ClassBasedNavigableIterableAssertIterable element
in order to perform assertions on it.
Navigational methods provided:
The available assertions after navigating to an element depend on the given assertClass
(AssertJ can't find the element assert type by itself because of Java type erasure).
Example with String element assertions:
Iterable<String> hobbits = newHashSet("frodo", "sam", "pippin");
// assertion succeeds with String assertions chained after first()
assertThat(hobbits, StringAssert.class).first()
.startsWith("fro")
.endsWith("do");ACTUAL - The actual typeELEMENT - The actual elements typeELEMENT_ASSERT - The actual elements AbstractAssert typeactual - the actual value.assertClass - the class used to create the elements assert instance.default AbstractBooleanAssert<?> assertThat(Boolean actual)
BooleanAssertactual - the actual value.default AbstractBooleanArrayAssert<?> assertThat(boolean[] actual)
BooleanArrayAssertactual - the actual value.default Boolean2DArrayAssert assertThat(boolean[][] actual)
Boolean2DArrayAssertactual - the actual value.default AbstractByteAssert<?> assertThat(byte actual)
ByteAssertactual - the actual value.default AbstractByteAssert<?> assertThat(Byte actual)
ByteAssertactual - the actual value.default AbstractByteArrayAssert<?> assertThat(byte[] actual)
ByteArrayAssertactual - the actual value.default Byte2DArrayAssert assertThat(byte[][] actual)
Byte2DArrayAssertactual - the actual value.default AbstractBooleanAssert<?> assertThat(boolean actual)
BooleanAssertactual - the actual value.default AbstractFloatAssert<?> assertThat(float actual)
FloatAssertactual - the actual value.default AbstractInputStreamAssert<?,? extends InputStream> assertThat(InputStream actual)
InputStreamAssertactual - the actual value.default AbstractFileAssert<?> assertThat(File actual)
FileAssertactual - the actual value.default <RESULT> FutureAssert<RESULT> assertThat(Future<RESULT> actual)
Future.RESULT - the type of the value contained in the Future.actual - the actual value.default AbstractPathAssert<?> assertThat(Path actual)
PathAssertactual - the path to testdefault AbstractPathAssert<?> assertThatPath(Path actual)
PathAssert
Use this over assertThat(Path) in case of ambiguous method resolution when the object under test
implements several interfaces Assertj provides assertThat for.
actual - the path to testdefault AbstractIntArrayAssert<?> assertThat(int[] actual)
IntArrayAssertactual - the actual value.default Int2DArrayAssert assertThat(int[][] actual)
Int2DArrayAssertactual - the actual value.default AbstractFloatAssert<?> assertThat(Float actual)
FloatAssertactual - the actual value.default Float2DArrayAssert assertThat(float[][] actual)
Float2DArrayAssertactual - the actual value.default AbstractIntegerAssert<?> assertThat(int actual)
IntegerAssertactual - the actual value.default AbstractFloatArrayAssert<?> assertThat(float[] actual)
FloatArrayAssertactual - the actual value.default AbstractIntegerAssert<?> assertThat(Integer actual)
IntegerAssertactual - the actual value.default AbstractDoubleAssert<?> assertThat(double actual)
DoubleAssertactual - the actual value.default AbstractDoubleAssert<?> assertThat(Double actual)
DoubleAssertactual - the actual value.default <E> AbstractCollectionAssert<?,Collection<? extends E>,E,ObjectAssert<E>> assertThat(Collection<? extends E> actual)
CollectionAssertE - the type of elements.actual - the actual value.default <E> AbstractCollectionAssert<?,Collection<? extends E>,E,ObjectAssert<E>> assertThatCollection(Collection<? extends E> actual)
CollectionAssert
Use this over assertThat(Collection) in case of ambiguous method resolution when the object under test
implements several interfaces Assertj provides assertThat for.
E - the type of elements.actual - the actual value.default <T> ListAssert<T> assertThat(List<? extends T> actual)
ListAssertT - the type of elements.actual - the actual value.default <ELEMENT> ListAssert<ELEMENT> assertThatList(List<? extends ELEMENT> actual)
ListAssert
Use this over assertThat(List) in case of ambiguous method resolution when the object under test
implements several interfaces Assertj provides assertThat for.
ELEMENT - the type of elements.actual - the actual value.default <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(List<? extends ELEMENT> actual, Class<ELEMENT_ASSERT> assertClass)
ClassBasedNavigableListAssertList element
in order to perform assertions on it.
Navigational methods provided:
The available assertions after navigating to an element depend on the given assertClass
(AssertJ can't find the element assert type by itself because of Java type erasure).
Example with String element assertions:
List<String> hobbits = newArrayList("frodo", "sam", "pippin");
// assertion succeeds with String assertions chained after first()
assertThat(hobbits, StringAssert.class).first()
.startsWith("fro")
.endsWith("do");ACTUAL - The actual typeELEMENT - The actual elements typeELEMENT_ASSERT - The actual elements AbstractAssert typeactual - the actual value.assertClass - the class used to create the elements assert instance.default <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(List<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)
FactoryBasedNavigableListAssertList element
in order to perform assertions on it.
Navigational methods provided:
The available assertions after navigating to an element depend on the ELEMENT_ASSERT parameter of the given
AssertFactory<ELEMENT, ELEMENT_ASSERT> (AssertJ can't figure it out because of Java type erasure).
Example with String element assertions:
List<String> hobbits = newArrayList("frodo", "sam", "pippin");
// build an AssertFactory for StringAssert (much nicer with Java 8 lambdas)
AssertFactory<String, StringAssert> stringAssertFactory = new AssertFactory<String, StringAssert>() {
@Override
public StringAssert createAssert(String string) {
return new StringAssert(string);
}
};
// assertion succeeds with String assertions chained after first()
assertThat(hobbits, stringAssertFactory).first()
.startsWith("fro")
.endsWith("do");ACTUAL - The actual typeELEMENT - The actual elements typeELEMENT_ASSERT - The actual elements AbstractAssert typeactual - the actual value.assertFactory - the factory used to create the elements assert instance.default <ELEMENT> ListAssert<ELEMENT> assertThat(Stream<? extends ELEMENT> actual)
ListAssertStream.
Be aware that the Stream under test will be converted to a List when an assertions require to inspect its content.
Once this is done the Stream can't reused as it would have been consumed.
Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the Stream.
Examples:
// you can chain multiple assertions on the Stream as it is converted to a List
assertThat(Stream.of(1, 2, 3)).contains(1)
.doesNotContain(42);The following assertion fails as the Stream under test is converted to a List before being compared to the expected Stream:
// FAIL: the Stream under test is converted to a List and compared to a Stream but a List is not a Stream.
assertThat(Stream.of(1, 2, 3)).isEqualTo(Stream.of(1, 2, 3));
These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the Stream to a List.
// The following assertions succeed as it only performs reference checking which does not require to convert the Stream to a List
Stream<Integer> stream = Stream.of(1, 2, 3);
assertThat(stream).isEqualTo(stream)
.isSameAs(stream);ELEMENT - the type of elements.actual - the actual Stream value.default <ELEMENT> ListAssert<ELEMENT> assertThatStream(Stream<? extends ELEMENT> actual)
ListAssertStream.
Use this over assertThat(Stream) in case of ambiguous method resolution when the object under test
implements several interfaces Assertj provides assertThat for.
Be aware that the Stream under test will be converted to a List when an assertions require to inspect its content.
Once this is done the Stream can't reused as it would have been consumed.
Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the Stream.
Examples:
// you can chain multiple assertions on the Stream as it is converted to a List
assertThat(Stream.of(1, 2, 3)).contains(1)
.doesNotContain(42);The following assertion fails as the Stream under test is converted to a List before being compared to the expected Stream:
// FAIL: the Stream under test is converted to a List and compared to a Stream but a List is not a Stream.
assertThat(Stream.of(1, 2, 3)).isEqualTo(Stream.of(1, 2, 3));
These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the Stream to a List.
// The following assertions succeed as it only performs reference checking which does not require to convert the Stream to a List
Stream<Integer> stream = Stream.of(1, 2, 3);
assertThat(stream).isEqualTo(stream)
.isSameAs(stream);ELEMENT - the type of elements.actual - the actual value.default ListAssert<Double> assertThat(DoubleStream actual)
ListAssertDoubleStream.
Be aware that the DoubleStream under test will be converted to a List when an assertions require to inspect its content.
Once this is done the DoubleStream can't reused as it would have been consumed.
Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the DoubleStream.
Examples:
// you can chain multiple assertions on the DoubleStream as it is converted to a List
assertThat(DoubleStream.of(1.0, 2.0, 3.0)).contains(1.0)
.doesNotContain(42.0);The following assertion fails as the DoubleStream under test is converted to a List before being compared to the expected DoubleStream:
// FAIL: the DoubleStream under test is converted to a List and compared to a DoubleStream but a List is not a DoubleStream.
assertThat(DoubleStream.of(1.0, 2.0, 3.0)).isEqualTo(DoubleStream.of(1.0, 2.0, 3.0));
These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the DoubleStream to a List.
// The following assertions succeed as it only performs reference checking which does not require to convert the DoubleStream to a List
DoubleStream stream = DoubleStream.of(1.0, 2.0, 3.0);
assertThat(stream).isEqualTo(stream)
.isSameAs(stream);actual - the actual DoubleStream value.default ListAssert<Long> assertThat(LongStream actual)
ListAssertLongStream.
Be aware that the LongStream under test will be converted to a List when an assertions require to inspect its content.
Once this is done the LongStream can't reused as it would have been consumed.
Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the LongStream.
Examples:
// you can chain multiple assertions on the LongStream as it is converted to a List
assertThat(LongStream.of(1, 2, 3)).contains(1)
.doesNotContain(42);The following assertion fails as the LongStream under test is converted to a List before being compared to the expected LongStream:
// FAIL: the LongStream under test is converted to a List and compared to a LongStream but a List is not a LongStream.
assertThat(LongStream.of(1, 2, 3)).isEqualTo(LongStream.of(1, 2, 3));
These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the LongStream to a List.
// The following assertions succeed as it only performs reference checking which does not require to convert the LongStream to a List
LongStream stream = LongStream.of(1, 2, 3);
assertThat(stream).isEqualTo(stream)
.isSameAs(stream);actual - the actual LongStream value.default ListAssert<Integer> assertThat(IntStream actual)
ListAssertIntStream.
Be aware that the IntStream under test will be converted to a List when an assertions require to inspect its content.
Once this is done the IntStream can't reused as it would have been consumed.
Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the IntStream.
Examples:
// you can chain multiple assertions on the IntStream as it is converted to a List
assertThat(IntStream.of(1, 2, 3)).contains(1)
.doesNotContain(42);The following assertion fails as the IntStream under test is converted to a List before being compared to the expected IntStream:
// FAIL: the IntStream under test is converted to a List and compared to a IntStream but a List is not a IntStream.
assertThat(IntStream.of(1, 2, 3)).isEqualTo(IntStream.of(1, 2, 3));
These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the IntStream to a List.
// The following assertions succeed as it only performs reference checking which does not require to convert the IntStream to a List
IntStream stream = IntStream.of(1, 2, 3);
assertThat(stream).isEqualTo(stream)
.isSameAs(stream);actual - the actual IntStream value.default AbstractDoubleArrayAssert<?> assertThat(double[] actual)
DoubleArrayAssertactual - the actual value.default Double2DArrayAssert assertThat(double[][] actual)
Double2DArrayAssertactual - the actual value.default Properties<Object> extractProperty(String propertyName)
Properties.extractProperty(String) so that Assertions offers a full feature entry point
to
all AssertJ features (but you can use Properties if you prefer).
Typical usage is to chain extractProperty with from method, see examples below :
// extract simple property values, as no type has been defined the extracted property will be considered as Object
// to define the real property type (here String) use extractProperty("name", String.class) instead.
assertThat(extractProperty("name").from(fellowshipOfTheRing))
.contains("Boromir", "Gandalf", "Frodo", "Legolas")
.doesNotContain("Sauron", "Elrond");
// extracting property works also with user's types (here Race), even though it will be considered as Object
// to define the real property type (here String) use extractProperty("name", Race.class) instead.
assertThat(extractProperty("race").from(fellowshipOfTheRing)).contains(HOBBIT, ELF).doesNotContain(ORC);
// extract nested property on Race
assertThat(extractProperty("race.name").from(fellowshipOfTheRing)).contains("Hobbit", "Elf").doesNotContain("Orc"); propertyName - the name of the property to be read from the elements of a Iterable. It may be a nested
property (e.g. "address.street.number").Properties.NullPointerException - if the given property name is null.IllegalArgumentException - if the given property name is empty.default <T> Properties<T> extractProperty(String propertyName, Class<T> propertyType)
Properties.extractProperty(String) so that Assertions offers a full feature entry point
to
all AssertJ features (but you can use Properties if you prefer).
Typical usage is to chain extractProperty with from method, see examples below :
// extract simple property values having a java standard type (here String)
assertThat(extractProperty("name", String.class).from(fellowshipOfTheRing))
.contains("Boromir", "Gandalf", "Frodo", "Legolas")
.doesNotContain("Sauron", "Elrond");
// extracting property works also with user's types (here Race)
assertThat(extractProperty("race", String.class).from(fellowshipOfTheRing))
.contains(HOBBIT, ELF).doesNotContain(ORC);
// extract nested property on Race
assertThat(extractProperty("race.name", String.class).from(fellowshipOfTheRing))
.contains("Hobbit", "Elf")
.doesNotContain("Orc");T - the type of value to extract.propertyName - the name of the property to be read from the elements of a Iterable. It may be a nested
property (e.g. "address.street.number").propertyType - the type of property to extractProperties.NullPointerException - if the given property name is null.IllegalArgumentException - if the given property name is empty.default Tuple tuple(Object... values)
Tuple when working with AbstractIterableAssert.extracting(String...) or
AbstractObjectArrayAssert.extracting(String...)default Index atIndex(int index)
Index.atIndex(int) so that Assertions offers a full feature entry point to all AssertJ
features (but you can use Index if you prefer).
Typical usage :
List<Ring> elvesRings = newArrayList(vilya, nenya, narya);
assertThat(elvesRings).contains(vilya, atIndex(0)).contains(nenya, atIndex(1)).contains(narya, atIndex(2));index - the value of the index.Index.IllegalArgumentException - if the given value is negative.default Offset<Double> within(Double value)
offset(Double) to use with isCloseTo assertions.
Typical usage :
assertThat(8.1).isCloseTo(8.0, within(0.1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<BigDecimal> within(BigDecimal value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(BigDecimal.TEN).isCloseTo(new BigDecimal("10.5"), within(BigDecimal.ONE));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Float> within(Float value)
offset(Float) to use with isCloseTo assertions.
Typical usage :
assertThat(8.2f).isCloseTo(8.0f, within(0.2f));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Double> withPrecision(Double value)
Offset.
Typical usage :
assertThat(8.1).isEqualTo(8.0, offset(0.1));value - the allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Float> withPrecision(Float value)
Offset.
Typical usage :
assertThat(8.2f).isCloseTo(8.0f, offset(0.2f));value - the allowed offsetOffset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<BigInteger> within(BigInteger value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(BigInteger.TEN).isCloseTo(new BigInteger("11"), within(new BigInteger("2")));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Byte> within(Byte value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat((byte) 10).isCloseTo((byte) 11, within((byte) 1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Integer> within(Integer value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(10).isCloseTo(11, within(1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Short> within(Short value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(10).isCloseTo(11, within(1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Long> within(Long value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(5l).isCloseTo(7l, within(2l));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default TemporalUnitOffset within(long value, TemporalUnit unit)
TemporalUnitOffset with with less than or equal condition
to use with isCloseTo temporal assertions.
Typical usage :
LocalTime _07_10 = LocalTime.of(7, 10);
LocalTime _07_12 = LocalTime.of(7, 12);
assertThat(_07_10).isCloseTo(_07_12, within(5, ChronoUnit.MINUTES));value - the allowed offsetunit - the TemporalUnit of the offsetOffset.default Duration withMarginOf(Duration allowedDifference)
AbstractDurationAssert.isCloseTo(Duration, Duration) assertion.
Example:
assertThat(Duration.ofMinutes(2)).isCloseTo(Duration.ofMinutes(3), withMarginOf(Duration.ofMinutes(1)));allowedDifference - the allowed difference Duration.default Percentage withinPercentage(Double value)
Percentage to use with isCloseTo assertions for
percentages.
Typical usage :
assertThat(11.0).isCloseTo(10.0, withinPercentage(10.0));value - the required precision percentagePercentage.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Percentage withinPercentage(Integer value)
Percentage to use with isCloseTo assertions for
percentages.
Typical usage :
assertThat(11).isCloseTo(10, withinPercentage(10));value - the required precision percentagePercentage.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Percentage withinPercentage(Long value)
Percentage to use with isCloseTo assertions for
percentages.
Typical usage :
assertThat(11L).isCloseTo(10L, withinPercentage(10L));value - the required precision percentagePercentage.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Double> byLessThan(Double value)
offset(Double) to use with isCloseTo assertions.
Typical usage :
assertThat(8.1).isCloseTo(8.0, byLessThan(0.1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Float> byLessThan(Float value)
offset(Float) to use with isCloseTo assertions.
Typical usage :
assertThat(8.2f).isCloseTo(8.0f, byLessThan(0.2f));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<BigDecimal> byLessThan(BigDecimal value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(BigDecimal.TEN).isCloseTo(new BigDecimal("10.5"), byLessThan(BigDecimal.ONE));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<BigInteger> byLessThan(BigInteger value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(BigInteger.TEN).isCloseTo(new BigInteger("11"), byLessThan(new BigInteger("2")));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Byte> byLessThan(Byte value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat((byte) 10).isCloseTo((byte) 11, byLessThan((byte) 1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Integer> byLessThan(Integer value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(10).isCloseTo(11, byLessThan(1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Short> byLessThan(Short value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(10).isCloseTo(11, byLessThan(1));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default Offset<Long> byLessThan(Long value)
Offset to use with isCloseTo assertions.
Typical usage :
assertThat(5l).isCloseTo(7l, byLessThan(2l));value - the value of the offset.Offset.NullPointerException - if the given value is null.IllegalArgumentException - if the given value is negative.default TemporalUnitOffset byLessThan(long value, TemporalUnit unit)
TemporalUnitOffset with strict less than condition
to use with isCloseTo temporal assertions.
Typical usage :
LocalTime _07_10 = LocalTime.of(7, 10);
LocalTime _07_12 = LocalTime.of(7, 12);
assertThat(_07_10).isCloseTo(_07_12, byLessThan(5, ChronoUnit.MINUTES));value - the value of the offset.unit - the TemporalUnit of the offset.Offset.default <F,T> Function<F,T> from(Function<F,T> extractor)
AbstractObjectAssert.returns(Object, Function) and
AbstractObjectAssert.doesNotReturn(Object, Function).
Example:
Jedi yoda = new Jedi("Yoda", "Green");
assertThat(yoda).returns("Yoda", from(Jedi::getName))
.returns(2.4, from(Jedi::getHeight))
.doesNotReturn(null, from(Jedi::getWeight)); F - Type of test subjectT - Type of the property under the assertionextractor - A function to extract test subject's propertyextractordefault <T,ASSERT extends AbstractAssert<?,?>> InstanceOfAssertFactory<T,ASSERT> as(InstanceOfAssertFactory<T,ASSERT> assertFactory)
InstanceOfAssertFactory parameter.
Example:
Jedi yoda = new Jedi("Yoda", "Green");
assertThat(yoda).extracting(Jedi::getName, as(InstanceOfAssertFactories.STRING))
.startsWith("Yo");T - the type to use for the cast.ASSERT - the type of the resulting AssertassertFactory - the factory which verifies the type and creates the new AssertassertFactoryAssertions.as(InstanceOfAssertFactory)default <T> Condition<T> anyOf(Iterable<? extends Condition<? super T>> conditions)
AnyOfT - the type of object the given condition accept.conditions - the conditions to evaluate.AnyOf.NullPointerException - if the given iterable is null.NullPointerException - if any of the elements in the given iterable is null.default <T> Condition<T> anyOf(Condition<? super T>... conditions)
AnyOf.anyOf(Condition...) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use AnyOf if you prefer).
Typical usage (jedi and sith are Condition) :
assertThat("Vader").is(anyOf(jedi, sith));T - the type of object the given condition accept.conditions - the conditions to evaluate.AnyOf.default <T> DoesNotHave<T> doesNotHave(Condition<? super T> condition)
DoesNotHaveT - the type of object the given condition accept.condition - the condition to inverse.default String contentOf(File file, String charsetName)
assertThat(String).
Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative
with assertThat(File).
file - the file.charsetName - the name of the character set to use.IllegalArgumentException - if the given character set is not supported on this platform.UncheckedIOException - if an I/O exception occurs.default String contentOf(File file)
assertThat(String).
Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative
with assertThat(File).
file - the file.UncheckedIOException - if an I/O exception occurs.default String contentOf(File file, Charset charset)
assertThat(String).
Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative
with assertThat(File).
file - the file.charset - the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(File file)
file - the file.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(File file, String charsetName)
file - the file.charsetName - the name of the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(File file, Charset charset)
file - the file.charset - the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(Path path)
path - the path.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(Path path, String charsetName)
path - the file.charsetName - the name of the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(Path path, Charset charset)
path - the path.charset - the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default void setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)
removeAssertJRelatedElementsFromStackTrace - flag.default <T> T failBecauseExceptionWasNotThrown(Class<? extends Throwable> throwableClass)
AssertionError with a message explaining that a Throwable of given class was expected to be thrown
but had not been.
Assertions.shouldHaveThrown(Class) can be used as a replacement.
T - dummy return value typethrowableClass - the Throwable class that was expected to be thrown.doSomething(optional.orElseGet(() -> failBecauseExceptionWasNotThrown(IOException.class)));.AssertionError - with a message explaining that a Throwable of given class was expected to be thrown but had
not been.default <T> T shouldHaveThrown(Class<? extends Throwable> throwableClass)
AssertionError with a message explaining that a Throwable of given class was expected to be thrown
but had not been.T - dummy return value typethrowableClass - the Throwable class that was expected to be thrown.doSomething(optional.orElseGet(() -> shouldHaveThrown(IOException.class)));.AssertionError - with a message explaining that a Throwable of given class was expected to be thrown but had
not been.default void setMaxLengthForSingleLineDescription(int maxLengthForSingleLineDescription)
The following array will be formatted on one line as its length < 80:
String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice");
// formatted as:
["A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice"] String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice", "Guards! Guards! (Discworld)");
// formatted as:
["A Game of Thrones",
"The Lord of the Rings",
"Assassin's Apprentice",
"Guards! Guards! (Discworld)"]maxLengthForSingleLineDescription - the maximum length for an iterable/array to be displayed on one linedefault void setMaxElementsForPrinting(int maxElementsForPrinting)
Example with a value of 4.
The following array will be formatted entirely as it's length is <= 4:
String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice");
// formatted as:
["A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice"] String[] greatBooks = array("A Game of Thrones", "The Lord of the Rings", "Assassin's Apprentice", "Guards! Guards!", "The Lies of Locke Lamora", "Aux Ombres d’Abyme");
// formatted as:
["A Game of Thrones", "The Lord of the Rings", ... "The Lies of Locke Lamora", "Aux Ombres d’Abyme"]maxElementsForPrinting - the maximum elements that would be printed for iterables, arrays and maps.default void setMaxStackTraceElementsDisplayed(int maxStackTraceElementsDisplayed)
Throwable representation (by default this set to 3).
Examples:
static class Test1 {
static void boom() {
Test2.boom2();
}
static class Test2 {
static void boom2() {
throw new RuntimeException();
}
}
}Test1.boom() exception should be represented like this in error messages:
java.lang.RuntimeException
at org.assertj.core.presentation.Test1$Test2.boom2(StandardRepresentation_throwable_format_Test.java:35)
at org.assertj.core.presentation.Test1.boom(StandardRepresentation_throwable_format_Test.java:40);java.lang.RuntimeException
at org.assertj.core.presentation.Test1.lambda$1(StandardRepresentation_throwable_format_Test.java:63)org.assertj.core.util.Throwables_Description_Test$test1$test2.exception_layer_2(Throwables_Description_Test.java:24)
...(69 remaining lines not displayed - this can be changed with Assertions.setMaxStackTraceElementsDisplayed)org.assertj.core.util.Throwables_Description_Test$test1.exception_layer_1(Throwables_Description_Test.java:30)maxStackTraceElementsDisplayed - the maximum number of lines for a stacktrace to be displayed on one throw.Configurationstatic void setPrintAssertionsDescription(boolean printAssertionsDescription)
The printed assertions description include all the successful assertions description and respectively the first failed one for standard assertions and all failed ones for soft assertions.
If you want to process the description differently, create a Consumer<Description> and register it with setDescriptionConsumer(Consumer).
printAssertionsDescription - whether to print assertions description.static void setDescriptionConsumer(Consumer<Description> descriptionConsumer)
Consumer<Description> allowing for example to record them in a file.
The consumed descriptions include all the successful assertions description and respectively the first failed one for standard assertions and all failed ones for soft assertions.
descriptionConsumer - the Description consumerdefault void setAllowExtractingPrivateFields(boolean allowExtractingPrivateFields)
IterableAssert#extracting(String)ObjectArrayAssert#extracting(String)allowExtractingPrivateFields - allow private fields extraction. Default true.default void setAllowComparingPrivateFields(boolean allowComparingPrivateFields)
AbstractIterableAssert.usingElementComparatorOnFields(java.lang.String...)AbstractObjectAssert.isEqualToComparingFieldByField(Object)false and these methods try to compare private fields, it will fail with an exception.allowComparingPrivateFields - allow private fields comparison. Default true.default void setExtractBareNamePropertyMethods(boolean barenamePropertyMethods)
String name().
Defaults to enabled.barenamePropertyMethods - whether bare-named property methods are founddefault void setLenientDateParsing(boolean value)
With strict parsing, inputs must match exactly date/time format.
Example:
final Date date = Dates.parse("2001-02-03");
final Date dateTime = parseDatetime("2001-02-03T04:05:06");
final Date dateTimeWithMs = parseDatetimeWithMs("2001-02-03T04:05:06.700");
Assertions.setLenientDateParsing(true);
// assertions will pass
assertThat(date).isEqualTo("2001-01-34");
assertThat(date).isEqualTo("2001-02-02T24:00:00");
assertThat(date).isEqualTo("2001-02-04T-24:00:00.000");
assertThat(dateTime).isEqualTo("2001-02-03T04:05:05.1000");
assertThat(dateTime).isEqualTo("2001-02-03T04:04:66");
assertThat(dateTimeWithMs).isEqualTo("2001-02-03T04:05:07.-300");
// assertions will fail
assertThat(date).hasSameTimeAs("2001-02-04"); // different date
assertThat(dateTime).hasSameTimeAs("2001-02-03 04:05:06"); // leniency does not help heresetLenientDateParsing(false).value - whether lenient parsing mode should be enabled or notdefault void registerCustomDateFormat(DateFormat userCustomDateFormat)
AbstractDateAssert.isEqualTo(String).
User date formats are used before default ones in the order they have been registered (first registered, first used).
AssertJ is gonna use any date formats registered with one of these methods :
AbstractDateAssert.withDateFormat(String)AbstractDateAssert.withDateFormat(java.text.DateFormat)registerCustomDateFormat(java.text.DateFormat)registerCustomDateFormat(String)Beware that AssertJ will use the newly registered format for all remaining Date assertions in the test suite
To revert to default formats only, call useDefaultDateFormatsOnly() or
AbstractDateAssert.withDefaultDateFormatsOnly().
Code examples:
Date date = ... // set to 2003 April the 26th
assertThat(date).isEqualTo("2003-04-26");
try {
// date with a custom format : failure since the default formats don't match.
assertThat(date).isEqualTo("2003/04/26");
} catch (AssertionError e) {
assertThat(e).hasMessage("Failed to parse 2003/04/26 with any of these date formats: " +
"[yyyy-MM-dd'T'HH:mm:ss.SSS, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd]");
}
// registering a custom date format to make the assertion pass
registerCustomDateFormat(new SimpleDateFormat("yyyy/MM/dd")); // registerCustomDateFormat("yyyy/MM/dd") would work to.
assertThat(date).isEqualTo("2003/04/26");
// the default formats are still available and should work
assertThat(date).isEqualTo("2003-04-26");userCustomDateFormat - the new Date format used for String based Date assertions.default void registerCustomDateFormat(String userCustomDateFormatPattern)
AbstractDateAssert.isEqualTo(String).
User date formats are used before default ones in the order they have been registered (first registered, first used).
AssertJ is gonna use any date formats registered with one of these methods :
AbstractDateAssert.withDateFormat(String)AbstractDateAssert.withDateFormat(java.text.DateFormat)registerCustomDateFormat(java.text.DateFormat)registerCustomDateFormat(String)Beware that AssertJ will use the newly registered format for all remaining Date assertions in the test suite.
To revert to default formats only, call useDefaultDateFormatsOnly() or
AbstractDateAssert.withDefaultDateFormatsOnly().
Code examples:
Date date = ... // set to 2003 April the 26th
assertThat(date).isEqualTo("2003-04-26");
try {
// date with a custom format : failure since the default formats don't match.
assertThat(date).isEqualTo("2003/04/26");
} catch (AssertionError e) {
assertThat(e).hasMessage("Failed to parse 2003/04/26 with any of these date formats: " +
"[yyyy-MM-dd'T'HH:mm:ss.SSS, yyyy-MM-dd'T'HH:mm:ss, yyyy-MM-dd]");
}
// registering a custom date format to make the assertion pass
registerCustomDateFormat("yyyy/MM/dd");
assertThat(date).isEqualTo("2003/04/26");
// the default formats are still available and should work
assertThat(date).isEqualTo("2003-04-26");userCustomDateFormatPattern - the new Date format pattern used for String based Date assertions.default void useDefaultDateFormatsOnly()
Beware that the default formats are expressed in the current local timezone.
Defaults date format are:
yyyy-MM-dd'T'HH:mm:ss.SSSyyyy-MM-dd HH:mm:ss.SSS (for Timestamp String representation support)yyyy-MM-dd'T'HH:mm:ssyyyy-MM-ddExample of valid string date representations:
2003-04-26T03:01:02.9992003-04-26 03:01:02.9992003-04-26T13:01:022003-04-26default AbstractZonedDateTimeAssert<?> assertThat(ZonedDateTime actual)
ZonedDateTimeAssertactual - the actual value.default <RESULT> CompletableFutureAssert<RESULT> assertThat(CompletableFuture<RESULT> future)
CompletableFuture.RESULT - the type of the value contained in the CompletableFuture.future - the actual value.default <RESULT> CompletableFutureAssert<RESULT> assertThat(CompletionStage<RESULT> completionStage)
CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert.
If the given CompletionStage is null, the CompletableFuture in the returned CompletableFutureAssert will also be null.
RESULT - the type of the value contained in the CompletionStage.completionStage - the actual CompletionStage.default <VALUE> OptionalAssert<VALUE> assertThat(Optional<VALUE> optional)
Optional.VALUE - the type of the value contained in the Optional.optional - the actual value.default OptionalDoubleAssert assertThat(OptionalDouble optional)
OptionalDouble.optional - the actual value.default MatcherAssert assertThat(Matcher matcher)
Matchermatcher - the actual matcher.default OptionalIntAssert assertThat(OptionalInt optional)
OptionalInt.optional - the actual value.default OptionalLongAssert assertThat(OptionalLong optional)
OptionalLong.optional - the actual value.default AbstractLocalDateTimeAssert<?> assertThat(LocalDateTime localDateTime)
LocalDateTimeAssertlocalDateTime - the actual value.default AbstractLocalDateAssert<?> assertThat(LocalDate localDate)
LocalDateAssertlocalDate - the actual value.default AbstractLocalTimeAssert<?> assertThat(LocalTime localTime)
LocalTimeAssertlocalTime - the actual value.default AbstractInstantAssert<?> assertThat(Instant actual)
InstantAssertactual - the actual value.default AbstractDurationAssert<?> assertThat(Duration actual)
DurationAssertactual - the actual value.default AbstractPeriodAssert<?> assertThat(Period actual)
PeriodAssertactual - the actual value.default AbstractOffsetTimeAssert<?> assertThat(OffsetTime offsetTime)
OffsetTimeAssertoffsetTime - the actual value.default AbstractOffsetDateTimeAssert<?> assertThat(OffsetDateTime offsetDateTime)
OffsetTimeAssertoffsetDateTime - the actual value.default AbstractThrowableAssert<?,? extends Throwable> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Throwable (easier done with lambdas).
Example :
@Test
public void testException() {
assertThatThrownBy(() -> { throw new Exception("boom!") }).isInstanceOf(Exception.class)
.hasMessageContaining("boom");
}ThrowableAssert.ThrowingCallable does not raise an exception, an error is immediately thrown,
in that case the test description provided with as(String, Object...) is not honored.#catchThrowable(ThrowingCallable) as shown below:
// assertion will fail but "display me" won't appear in the error
assertThatThrownBy(() -> {}).as("display me")
.isInstanceOf(Exception.class);
// assertion will fail AND "display me" will appear in the error
Throwable thrown = catchThrowable(() -> {});
assertThat(thrown).as("display me")
.isInstanceOf(Exception.class);assertThatCode(ThrowingCallable) for the test description provided
with as(String, Object...) to always be honored.shouldRaiseThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.ThrowableAssert.default AbstractThrowableAssert<?,? extends Throwable> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, String description, Object... args)
Throwable like assertThatThrownBy(ThrowingCallable) but this method
let you set the assertion description the same way you do with as(String, Object...).
Example:
@Test
public void testException() {
// if this assertion failed (but it doesn't), the error message would start with [Test explosive code]
assertThatThrownBy(() -> { throw new IOException("boom!") }, "Test explosive code")
.isInstanceOf(IOException.class)
.hasMessageContaining("boom");
}ThrowingCallable does not raise an exception, an error is immediately thrown.
The test description provided is honored but not the one with as(String, Object...), example:
// assertion will fail but "display me" won't appear in the error message
assertThatThrownBy(() -> {}).as("display me")
.isInstanceOf(Exception.class);
// assertion will fail AND "display me" will appear in the error message
assertThatThrownBy(() -> {}, "display me")
.isInstanceOf(Exception.class);shouldRaiseThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.description - the new description to set.args - optional parameter if description is a format String.ThrowableAssert.default AbstractThrowableAssert<?,? extends Throwable> assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
Throwable more easily when used with Java 8 lambdas.
Example :
ThrowingCallable callable = () -> {
throw new Exception("boom!");
};
// assertion succeeds
assertThatCode(callable).isInstanceOf(Exception.class)
.hasMessageContaining("boom");
// assertion fails
assertThatCode(callable).doesNotThrowAnyException();ThrowableAssert.ThrowingCallable does not validate against next assertions, an error is immediately raised,
in that case the test description provided with as(String, Object...) is not honored.#catchThrowable(ThrowingCallable) as shown below.
ThrowingCallable doNothing = () -> {
// do nothing
};
// assertion fails and "display me" appears in the assertion error
assertThatCode(doNothing).as("display me")
.isInstanceOf(Exception.class);
// assertion will fail AND "display me" will appear in the error
Throwable thrown = catchThrowable(doNothing);
assertThatCode(thrown).as("display me")
.isInstanceOf(Exception.class);
This method was not named assertThat because the java compiler reported it ambiguous when used directly with a lambda :(
shouldRaiseOrNotThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.null if none was raised by the callable.default <T> ObjectAssert<T> assertThatObject(T actual)
ObjectAssert
This overload is useful, when an overloaded method of assertThat(...) takes precedence over the generic assertThat(Object).
Example:
Cast necessary becauseassertThat(List) "forgets" actual type:
assertThat(new LinkedList<>(asList("abc"))).matches(list -> ((Deque<String>) list).getFirst().equals("abc")); assertThatObject(new LinkedList<>(asList("abc"))).matches(list -> list.getFirst().equals("abc")); T - the type of the actual value.actual - the actual value.default <T> ObjectAssert<T> assertWith(T actual, Consumer<T>... requirements)
Consumer.
This is useful to avoid repeating getting the instance to test, a bit like a with block which turns the target into
the equivalent of this (as in Groovy for example).
Example:
assertWith(team.getPlayers().get(0).getStats(),
stats -> assertThat(stats.pointPerGame).isGreaterThan(25.7),
stats -> assertThat(stats.assistsPerGame).isGreaterThan(7.2),
stats -> assertThat(stats.reboundsPerGame).isBetween(9, 12)
);
assertWith is variation of AbstractAssert.satisfies(Consumer[]) hopefully easier to find for some users.
T - the type of the actual value.actual - the actual value.requirements - to assert on the actual object - must not be null.default Throwable catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
Throwable more easily when used with Java 8 lambdas.
This caught Throwable can then be asserted.
Example:
@Test
public void testException() {
// when
Throwable thrown = catchThrowable(() -> { throw new Exception("boom!"); });
// then
assertThat(thrown).isInstanceOf(Exception.class)
.hasMessageContaining("boom");
} shouldRaiseThrowable - The lambda with the code that should raise the exception.null if none was raised by the callable.#catchThrowableOfType(ThrowingCallable, Class)default <THROWABLE extends Throwable> THROWABLE catchThrowableOfType(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, Class<THROWABLE> type)
Throwable of a specific type.
A call is made to catchThrowable(ThrowingCallable), if no exception is thrown catchThrowableOfType returns null,
otherwise it checks that the caught Throwable has the specified type then casts it to it before returning it,
making it convenient to perform subtype-specific assertions on the result.
Example:
class CustomParseException extends Exception {
int line;
int column;
public CustomParseException(String msg, int l, int c) {
super(msg);
line = l;
column = c;
}
}
CustomParseException e = catchThrowableOfType(() -> { throw new CustomParseException("boom!", 1, 5); },
CustomParseException.class);
// assertions pass
assertThat(e).hasMessageContaining("boom");
assertThat(e.line).isEqualTo(1);
assertThat(e.column).isEqualTo(5);
// fails as CustomParseException is not a RuntimeException
catchThrowableOfType(() -> { throw new CustomParseException("boom!", 1, 5); },
RuntimeException.class);THROWABLE - the Throwable type.shouldRaiseThrowable - The lambda with the code that should raise the exception.type - The type of exception that the code is expected to raise.null if none was raised by the callable.#catchThrowable(ThrowingCallable)default Exception catchException(ThrowableAssert.ThrowingCallable shouldRaiseException)
Exception.
A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null
otherwise it checks that the caught Throwable is of type Exception and casts it making it convenient to perform subtype-specific assertions on it.
Example:
Exception exception = catchException(() -> {throw new Exception("boom!");});
// assertions succeed
assertThat(exception).hasMessage("boom!");
// succeeds as catchException returns null when the code does not throw any exceptions
assertThat(catchException(() -> {})).isNull();
// fails as the thrown instance is not an Exception
catchException(() -> {throw new Throwable("boom!");});shouldRaiseException - The lambda with the code that should raise the exception.null if none was raised by the callable.#catchThrowable(ThrowingCallable)default RuntimeException catchRuntimeException(ThrowableAssert.ThrowingCallable shouldRaiseRuntimeException)
RuntimeException.
A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null
otherwise it checks that the caught Throwable is of type RuntimeException and casts it making it convenient to perform subtype-specific assertions on it.
Example:
RuntimeException runtimeException = catchRuntimeException(() -> {throw new RuntimeException("boom!");});
// assertions succeed
assertThat(runtimeException).hasMessage("boom!");
// succeeds as catchRuntimeException returns null when the code does not throw any exceptions
assertThat(catchRuntimeException(() -> {})).isNull();
// fails as the thrown instance is not a RuntimeException
catchRuntimeException(() -> {throw new Exception("boom!");});shouldRaiseRuntimeException - The lambda with the code that should raise the exception.null if none was raised by the callable.#catchThrowable(ThrowingCallable)default NullPointerException catchNullPointerException(ThrowableAssert.ThrowingCallable shouldRaiseNullPointerException)
NullPointerException.
A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null
otherwise it checks that the caught Throwable is of type RuntimeException and casts it making it convenient to perform subtype-specific assertions on it.
Example:
NullPointerException nullPointerException = catchNullPointerException(() -> {throw new NullPointerException("boom!");});
// assertions succeed
assertThat(nullPointerException).hasMessage("boom!");
// succeeds as catchNullPointerException returns null when the code does not throw any exceptions
assertThat(catchNullPointerException(() -> {})).isNull();
// fails as the thrown instance is not a NullPointerException
catchNullPointerException(() -> {throw new Exception("boom!");});shouldRaiseNullPointerException - The lambda with the code that should raise the exception.null if none was raised by the callable.#catchThrowable(ThrowingCallable)default IllegalArgumentException catchIllegalArgumentException(ThrowableAssert.ThrowingCallable shouldRaiseIllegalArgumentException)
IllegalArgumentException.
A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null
otherwise it checks that the caught Throwable is of type IllegalArgumentException and casts it making it convenient to perform subtype-specific assertions on it.
Example:
IllegalArgumentException illegalArgumentException = catchIllegalArgumentException(() -> {throw new IllegalArgumentException("boom!");});
// assertions succeed
assertThat(illegalArgumentException).hasMessage("boom!");
// succeeds as catchNullPointerException returns null when the code does not throw any exceptions
assertThat(catchIllegalArgumentException(() -> {})).isNull();
// fails as the thrown instance is not an IllegalArgumentException
catchIllegalArgumentException(() -> {throw new Exception("boom!");});shouldRaiseIllegalArgumentException - The lambda with the code that should raise the exception.null if none was raised by the callable.#catchThrowable(ThrowingCallable)default IOException catchIOException(ThrowableAssert.ThrowingCallable shouldRaiseIOException)
IOException.
A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null
otherwise it checks that the caught Throwable is of type IOException and casts it making it convenient to perform subtype-specific assertions on it.
Example:
IOException iOException = catchIOException(() -> {throw new IOException("boom!");});
// assertions succeed
assertThat(iOException).hasMessage("boom!");
// succeeds as catchIOException returns null when the code does not throw any exceptions
assertThat(catchIOException(() -> {})).isNull();
// fails as the thrown instance is not an IOException
catchIOException(() -> {throw new Exception("boom!");});shouldRaiseIOException - The lambda with the code that should raise the exception.null if none was raised by the callable.#catchThrowable(ThrowingCallable)default ReflectiveOperationException catchReflectiveOperationException(ThrowableAssert.ThrowingCallable shouldRaiseReflectiveOperationException)
ReflectiveOperationException.
A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null
otherwise it checks that the caught Throwable is of type ReflectiveOperationException and casts it making it convenient to perform subtype-specific assertions on it.
Example:
ReflectiveOperationException reflectiveOperationException = catchReflectiveOperationException(() -> {throw new ReflectiveOperationException("boom!");});
// assertions succeed
assertThat(reflectiveOperationException).hasMessage("boom!");
// succeeds as catchReflectiveOperationException returns null when the code does not throw any exceptions
assertThat(catchReflectiveOperationException(() -> {})).isNull();
// fails as the thrown instance is not an IOException
catchReflectiveOperationException(() -> {throw new Exception("boom!");});shouldRaiseReflectiveOperationException - The lambda with the code that should raise the exception.null if none was raised by the callable.#catchThrowable(ThrowingCallable)default IllegalStateException catchIllegalStateException(ThrowableAssert.ThrowingCallable shouldRaiseIllegalStateException)
IllegalStateException.
A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null
otherwise it checks that the caught Throwable is of type IllegalStateException and casts it making it convenient to perform subtype-specific assertions on it.
Example:
IllegalStateException illegalStateException = catchIllegalStateException(() -> {throw new IllegalStateException("boom!");});
// assertions succeed
assertThat(illegalStateException).hasMessage("boom!");
// succeeds as catchReflectiveOperationException returns null when the code does not throw any exceptions
assertThat(catchIllegalStateException(() -> {})).isNull();
// fails as the thrown instance is not an IOException
catchIllegalStateException(() -> {throw new Exception("boom!");});shouldRaiseIllegalStateException - The lambda with the code that should raise the exception.null if none was raised by the callable.#catchThrowable(ThrowingCallable)default IndexOutOfBoundsException catchIndexOutOfBoundsException(ThrowableAssert.ThrowingCallable shouldRaiseIndexOutOfBoundException)
IndexOutOfBoundsException.
A call is made to catchThrowable(ThrowingCallable), if no exception is thrown it returns null
otherwise it checks that the caught Throwable is of type IndexOutOfBoundsException and casts it making it convenient to perform subtype-specific assertions on it.
Example:
IndexOutOfBoundsException indexOutOfBoundsException = catchIndexOutOfBoundsException(() -> {throw new IndexOutOfBoundsException("boom!");});
// assertions succeed
assertThat(indexOutOfBoundsException).hasMessage("boom!");
// succeeds as catchIndexOutOfBoundsException returns null when the code does not throw any exceptions
assertThat(catchIndexOutOfBoundsException(() -> {})).isNull();
// fails as the thrown instance is not an IOException
catchIndexOutOfBoundsException(() -> {throw new Exception("boom!");});shouldRaiseIndexOutOfBoundException - The lambda with the code that should raise the exception.null if none was raised by the callable.#catchThrowable(ThrowingCallable)default <T extends Throwable> ThrowableTypeAssert<T> assertThatExceptionOfType(Class<? extends T> exceptionType)
throwingCallable
which allows to chain assertions on the thrown exception.
Example:
assertThatExceptionOfType(IOException.class)
.isThrownBy(() -> { throw new IOException("boom!"); })
.withMessage("boom!"); #assertThatThrownBy(ThrowingCallable) but in a more natural way.T - the exception type.exceptionType - the exception type class.ThrowableTypeAssert.default NotThrownAssert assertThatNoException()
throwingCallable.
Example:
assertThatNoException().isThrownBy(() -> { System.out.println("OK"); });assertThatCode(...).doesNotThrowAnyException(); but in a more natural way.NotThrownAssert.default ThrowableTypeAssert<NullPointerException> assertThatNullPointerException()
assertThatExceptionOfType(Class) for NullPointerException.ThrowableTypeAssert.default ThrowableTypeAssert<IllegalArgumentException> assertThatIllegalArgumentException()
assertThatExceptionOfType(Class) for IllegalArgumentException.ThrowableTypeAssert.default ThrowableTypeAssert<IOException> assertThatIOException()
assertThatExceptionOfType(Class) for IOException.ThrowableTypeAssert.default ThrowableTypeAssert<IllegalStateException> assertThatIllegalStateException()
assertThatExceptionOfType(Class) for IllegalStateException.ThrowableTypeAssert.default ThrowableTypeAssert<Exception> assertThatException()
assertThatExceptionOfType(Class) for Exception.ThrowableTypeAssert.default ThrowableTypeAssert<IndexOutOfBoundsException> assertThatIndexOutOfBoundsException()
assertThatExceptionOfType(Class) for IndexOutOfBoundsException.ThrowableTypeAssert.default ThrowableTypeAssert<ReflectiveOperationException> assertThatReflectiveOperationException()
assertThatExceptionOfType(Class) for ReflectiveOperationException.ThrowableTypeAssert.default ThrowableTypeAssert<RuntimeException> assertThatRuntimeException()
assertThatExceptionOfType(Class) for RuntimeException.ThrowableTypeAssert.default <T> PredicateAssert<T> assertThat(Predicate<T> actual)
Predicate.T - the type of the value contained in the Predicate.actual - the actual value.default <T> PredicateAssert<T> assertThatPredicate(Predicate<T> actual)
Predicate.
Use this over assertThat(Iterable) in case of ambiguous method resolution when the object under test
implements several interfaces Assertj provides assertThat for.
T - the type of the value contained in the Predicate.actual - the actual value.default IntPredicateAssert assertThat(IntPredicate actual)
IntPredicate.actual - the actual value.default LongPredicateAssert assertThat(LongPredicate actual)
LongPredicate.actual - the actual value.default DoublePredicateAssert assertThat(DoublePredicate actual)
DoublePredicate.actual - the actual value.default AbstractUrlAssert<?> assertThat(URL actual)
UrlAssertactual - the actual value.default AbstractUriAssert<?> assertThat(URI actual)
UriAssertactual - the actual value.default <ELEMENT> SpliteratorAssert<ELEMENT> assertThat(Spliterator<ELEMENT> actual)
SpliteratorAssertELEMENT - the type of the elements.actual - the actual value.default <T> T assertThat(AssertProvider<T> component)
Assert to the AssertProvider.assertThat() of the given component.
Read the comments on AssertProvider for an example of its usage.
T - the AssertProvider wrapped type.component - the component that creates its own assertAssert of the given componentdefault <E> Filters<E> filter(E[] array)
Filters.filter(Object[]) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use Filters if you prefer).
Note that the given array is not modified, the filters are performed on an Iterable copy of the array.
Typical usage with Condition :
assertThat(filter(players).being(potentialMVP).get()).containsOnly(james, rose);and with filter language based on java bean property :
assertThat(filter(players).with("pointsPerGame").greaterThan(20).and("assistsPerGame").greaterThan(7).get())
.containsOnly(james, rose);E - the array elements type.array - the array to filter.Filtersdefault <E> Filters<E> filter(Iterable<E> iterableToFilter)
Filters.filter(Object[]) so that Assertions offers a full feature entry point to all
AssertJ features (but you can use Filters if you prefer).
Note that the given Iterable is not modified, the filters are performed on a copy.
Typical usage with Condition :
assertThat(filter(players).being(potentialMVP).get()).containsOnly(james, rose);and with filter language based on java bean property :
assertThat(filter(players).with("pointsPerGame").greaterThan(20)
.and("assistsPerGame").greaterThan(7).get())
.containsOnly(james, rose);default InFilter in(Object... values)
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches one of the given values.
As often, an example helps:
Employee yoda = new Employee(1L, new Name("Yoda"), 800);
Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);
Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26);
Employee noname = new Employee(4L, null, 50);
List<Employee> employees = newArrayList(yoda, luke, obiwan, noname);
assertThat(employees).filteredOn("age", in(800, 26))
.containsOnly(yoda, obiwan, luke);values - values to match (one match is sufficient)default NotInFilter notIn(Object... valuesNotToMatch)
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches does not match any of the given values.
As often, an example helps:
Employee yoda = new Employee(1L, new Name("Yoda"), 800);
Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);
Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26);
Employee noname = new Employee(4L, null, 50);
List<Employee> employees = newArrayList(yoda, luke, obiwan, noname);
assertThat(employees).filteredOn("age", notIn(800, 50))
.containsOnly(luke);valuesNotToMatch - values not to match (none of the values must match)default NotFilter not(Object valueNotToMatch)
FilterOperator to use in filteredOn(String, FilterOperation) to express a filter keeping all Iterable elements whose property/field
value matches does not match the given value.
As often, an example helps:
Employee yoda = new Employee(1L, new Name("Yoda"), 800);
Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);
Employee luke = new Employee(3L, new Name("Luke", "Skywalker"), 26);
Employee noname = new Employee(4L, null, 50);
List<Employee> employees = newArrayList(yoda, luke, obiwan, noname);
assertThat(employees).filteredOn("age", not(800))
.containsOnly(luke, noname);valueNotToMatch - the value not to matchdefault String contentOf(URL url, Charset charset)
assertThat(String).
Note that this will load the entire contents in memory.
url - the URL.charset - the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default String contentOf(URL url, String charsetName)
assertThat(String).
Note that this will load the entire contents in memory.
url - the URL.charsetName - the name of the character set to use.IllegalArgumentException - if the given character set is not supported on this platform.UncheckedIOException - if an I/O exception occurs.default String contentOf(URL url)
assertThat(String).
Note that this will load the entire file in memory; for larger files.
url - the URL.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(URL url)
url - the URL.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(URL url, Charset charset)
url - the URL.charset - the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default List<String> linesOf(URL url, String charsetName)
url - the URL.charsetName - the name of the character set to use.NullPointerException - if the given charset is null.UncheckedIOException - if an I/O exception occurs.default void useRepresentation(Representation customRepresentation)
Representation that will be used in all following assertions.
Representation are used to format types in assertions error messages.
An alternative way of using a different representation is to register one as a service,
this approach is described in Representation, it requires more work than this method
but has the advantage of not having to do anything in your tests and it would be applied to all the tests globally
Example :
private class Example {}
private class CustomRepresentation extends StandardRepresentation {
// override needed to hook specific formatting
@Override
public String toStringOf(Object o) {
if (o instanceof Example) return "Example";
// fallback to default formatting.
return super.toStringOf(o);
}
// change String representation
@Override
protected String toStringOf(String s) {
return "$" + s + "$";
}
}
Assertions.useRepresentation(new CustomRepresentation());
// this assertion fails ...
assertThat(new Example()).isNull();
// ... with error :
// "expected:<[null]> but was:<[Example]>"
// this one fails ...
assertThat("foo").startsWith("bar");
// ... with error :
// Expecting:
// <$foo$>
// to start with:
// <$bar$>customRepresentation - the Representation to usedefault <T> void registerFormatterForType(Class<T> type, Function<T,String> formatter)
Representation to format the different types involved, using this method
you can control the formatting of a given type by providing a specific formatter.
Registering a formatter makes it available for all AssertJ Representation:
Example :
// without specific formatter
assertThat(STANDARD_REPRESENTATION.toStringOf(123L)).isEqualTo("123L");
// register a formatter for Long
Assertions.registerFormatterForType(Long.class, value -> "$" + value + "$");
// now Long will be formatted between in $$ in error message.
assertThat(STANDARD_REPRESENTATION.toStringOf(longNumber)).isEqualTo("$123$");
// fails with error : expected:<$456$> but was:<$123$>
assertThat(123L).isEqualTo(456L);T - the type of format.type - the class of the type to formatformatter - the formatter Functiondefault void useDefaultRepresentation()
StandardRepresentation to revert the effect of calling useRepresentation(Representation).Copyright © 2025. All rights reserved.