org.assertj.core.api

Interface WithAssertions

public interface WithAssertions

A unified entry point to all non-deprecated assertions from both the new Java 8 core API and the pre-Java 8 core API. As a convenience, the methods are defined in an interface so that no static imports are necessary if the test class implements this interface. Based on an idea by David Gageot : http://blog.javabien.net/2014/04/23/what-if-assertj-used-java-8/

Author:

Alan Rothkopf

Method Summary

Modifier and Type	Method and Description
default <T> Condition<T>	allOf(Condition<? super T>... conditions) Delegate call to Assertions.allOf(Condition[])
default <T> Condition<T>	allOf(Iterable<? extends Condition<? super T>> conditions) Delegate call to Assertions.allOf(Iterable)
default <T> Condition<T>	anyOf(Condition<? super T>... conditions) Delegate call to Assertions.anyOf(Condition[])
default <T> Condition<T>	anyOf(Iterable<? extends Condition<? super T>> conditions) Delegate call to Assertions.anyOf(Iterable)
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) Delegate call to Assertions.assertThat(Iterable, Class)
default <T> T	assertThat(AssertProvider<T> component) Delegate call to Assertions.assertThat(AssertProvider)
default AbstractBigDecimalAssert<?>	assertThat(BigDecimal actual) Delegate call to Assertions.assertThat(BigDecimal)
default AbstractBooleanAssert<?>	assertThat(boolean actual) Delegate call to Assertions.assertThat(boolean)
default AbstractBooleanAssert<?>	assertThat(Boolean actual) Delegate call to Assertions.assertThat(Boolean)
default AbstractBooleanArrayAssert<?>	assertThat(boolean[] actual) Delegate call to Assertions.assertThat(boolean)
default AbstractByteAssert<?>	assertThat(byte actual) Delegate call to Assertions.assertThat(byte)
default AbstractByteAssert<?>	assertThat(Byte actual) Delegate call to Assertions.assertThat(Byte)
default AbstractByteArrayAssert<?>	assertThat(byte[] actual) Delegate call to Assertions.assertThat(byte[])
default AbstractCharacterAssert<?>	assertThat(char actual) Delegate call to Assertions.assertThat(char)
default AbstractCharArrayAssert<?>	assertThat(char[] actual) Delegate call to Assertions.assertThat(char[])
default AbstractCharacterAssert<?>	assertThat(Character actual) Delegate call to Assertions.assertThat(Character)
default AbstractCharSequenceAssert<?,? extends CharSequence>	assertThat(CharSequence actual) Delegate call to Assertions.assertThat(CharSequence)
default AbstractClassAssert<?>	assertThat(Class<?> actual) Delegate call to Assertions.assertThat(Class)
default <T> CompletableFutureAssert<T>	assertThat(CompletableFuture<T> future) Delegate call to Assertions.assertThat(CompletableFuture)
default AbstractDateAssert<?>	assertThat(Date actual) Delegate call to Assertions.assertThat(Date)
default AbstractDoubleAssert<?>	assertThat(double actual) Delegate call to Assertions.assertThat(double)
default AbstractDoubleAssert<?>	assertThat(Double actual) Delegate call to Assertions.assertThat(Double)
default AbstractDoubleArrayAssert<?>	assertThat(double[] actual) Delegate call to Assertions.assertThat(double[])
default DoublePredicateAssert	assertThat(DoublePredicate actual) Delegate call to Assertions.assertThat(DoublePredicate)
default AbstractFileAssert<?>	assertThat(File actual) Delegate call to Assertions.assertThat(File)
default AbstractFloatAssert<?>	assertThat(float actual) Delegate call to Assertions.assertThat(float)
default AbstractFloatAssert<?>	assertThat(Float actual) Delegate call to Assertions.assertThat(Float)
default AbstractFloatArrayAssert<?>	assertThat(float[] actual) Delegate call to Assertions.assertThat(float[])
default AbstractInputStreamAssert<?,? extends InputStream>	assertThat(InputStream actual) Delegate call to Assertions.assertThat(InputStream)
default AbstractIntegerAssert<?>	assertThat(int actual) Delegate call to Assertions.assertThat(int)
default AbstractIntArrayAssert<?>	assertThat(int[] actual) Delegate call to Assertions.assertThat(int[])
default AbstractIntegerAssert<?>	assertThat(Integer actual) Delegate call to Assertions.assertThat(Integer)
default IntPredicateAssert	assertThat(IntPredicate actual) Delegate call to Assertions.assertThat(IntPredicate)
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) Delegate call to Assertions.assertThat(Iterable, AssertFactory)
default <T> IterableAssert<T>	assertThat(Iterable<? extends T> actual) Delegate call to Assertions.assertThat(Iterable)
default <T> IterableAssert<T>	assertThat(Iterator<? extends T> actual) Delegate call to Assertions.assertThat(Iterator)
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) Delegate call to Assertions.assertThat(List, AssertFactory) )}
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) Delegate call to Assertions.assertThat(List, Class) )}
default <T> ListAssert<? extends T>	assertThat(List<? extends T> actual) Delegate call to Assertions.assertThat(List)
default AbstractLocalDateAssert<?>	assertThat(LocalDate localDate) Delegate call to Assertions.assertThat(LocalDate)
default AbstractLocalDateTimeAssert<?>	assertThat(LocalDateTime localDateTime) Delegate call to Assertions.assertThat(LocalDateTime)
default AbstractLocalTimeAssert<?>	assertThat(LocalTime localTime) Delegate call to Assertions.assertThat(LocalTime)
default AbstractLongAssert<?>	assertThat(long actual) Delegate call to Assertions.assertThat(long)
default AbstractLongAssert<?>	assertThat(Long actual) Delegate call to Assertions.assertThat(Long)
default AbstractLongArrayAssert<?>	assertThat(long[] actual) Delegate call to Assertions.assertThat(long[])
default LongPredicateAssert	assertThat(LongPredicate actual) Delegate call to Assertions.assertThat(LongPredicate)
default <K,V> MapAssert<K,V>	assertThat(Map<K,V> actual) Delegate call to Assertions.assertThat(Map)
default AbstractOffsetDateTimeAssert<?>	assertThat(OffsetDateTime offsetDateTime) Delegate call to Assertions.assertThat(OffsetDateTime)
default AbstractOffsetTimeAssert<?>	assertThat(OffsetTime offsetTime) Delegate call to Assertions.assertThat(OffsetTime)
default <T> OptionalAssert<T>	assertThat(Optional<T> optional) Delegate call to Assertions.assertThat(Optional)
default OptionalDoubleAssert	assertThat(OptionalDouble optional) Delegate call to Assertions.assertThat(java.util.OptionalDouble)
default OptionalIntAssert	assertThat(OptionalInt optional) Delegate call to Assertions.assertThat(java.util.OptionalInt)
default OptionalLongAssert	assertThat(OptionalLong optional) Delegate call to Assertions.assertThat(java.util.OptionalLong)
default AbstractPathAssert<?>	assertThat(Path actual) Delegate call to Assertions.assertThat(Path)
default <T> PredicateAssert<T>	assertThat(Predicate<T> actual) Delegate call to Assertions.assertThat(Predicate)
default AbstractShortAssert<?>	assertThat(short actual) Delegate call to Assertions.assertThat(short)
default AbstractShortAssert<?>	assertThat(Short actual) Delegate call to Assertions.assertThat(Short)
default AbstractShortArrayAssert<?>	assertThat(short[] actual) Delegate call to Assertions.assertThat(short[])
default <T> AbstractListAssert<?,? extends List<? extends T>,T,ObjectAssert<T>>	assertThat(Stream<? extends T> actual) Delegate call to Assertions.assertThat(List)
default AbstractCharSequenceAssert<?,String>	assertThat(String actual) Delegate call to Assertions.assertThat(String)
default <T> AbstractObjectAssert<?,T>	assertThat(T actual) Delegate call to org.assertj.core.api.Assertions#assertThat(T)
default <T extends Comparable<? super T>> AbstractComparableAssert<?,T>	assertThat(T actual) Delegate call to Assertions.assertThat(Comparable)
default <T extends AssertDelegateTarget> T	assertThat(T assertion) Delegate call to Assertions.assertThat(AssertDelegateTarget)
default <T> AbstractObjectArrayAssert<?,T>	assertThat(T[] actual) Delegate call to org.assertj.core.api.Assertions#assertThat(T[])
default AbstractThrowableAssert<?,? extends Throwable>	assertThat(Throwable actual) Delegate call to Assertions.assertThat(Throwable)
default AbstractUriAssert<?>	assertThat(URI actual) Delegate call to Assertions.assertThat(URI)
default AbstractUrlAssert<?>	assertThat(URL actual) Delegate call to Assertions.assertThat(URL)
default AbstractZonedDateTimeAssert<?>	assertThat(ZonedDateTime actual) Delegate call to Assertions.assertThat(ZonedDateTime)
default <T extends Throwable> ThrowableTypeAssert<T>	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 AbstractThrowableAssert<?,? extends Throwable>	assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) Delegate call to org.assertj.core.api.Assertions#assertThatThrownBy(ThrowingCallable)
default Index	atIndex(int actual) Delegate call to Assertions.atIndex(int)
default Throwable	catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable) Delegate call to org.assertj.core.api.Assertions#catchThrowable(ThrowingCallable)
default String	contentOf(File actual) Delegate call to Assertions.contentOf(File)
default String	contentOf(File file, Charset charset) Delegate call to Assertions.contentOf(File,Charset)
default String	contentOf(File file, String charsetName) Delegate call to Assertions.contentOf(File,String)
default <T> DoesNotHave<T>	doesNotHave(Condition<? super T> condition) Delegate call to Assertions.doesNotHave(Condition)
default <K,V> MapEntry<K,V>	entry(K key, V value) Delegate call to Assertions.entry(Object, Object)
default Properties<Object>	extractProperty(String propertyName) Delegate call to Assertions.extractProperty(String)
default <T> Properties<T>	extractProperty(String propertyName, Class<T> propertyType) Delegate call to Assertions.extractProperty(String,Class)
default void	fail(String failureMessage) Delegate call to Assertions.fail(String)
default void	fail(String failureMessage, Throwable realCause) Delegate call to Assertions.fail(String,Throwable)
default void	failBecauseExceptionWasNotThrown(Class<? extends Throwable> exceptionClass) Delegate call to Assertions.failBecauseExceptionWasNotThrown(java.lang.Class<? extends java.lang.Throwable>)
default <E> Filters<E>	filter(E[] array) Delegate call to org.assertj.core.api.Assertions#filter(E[])
default <E> Filters<E>	filter(Iterable<E> iterableToFilter) Delegate call to Assertions.filter(Iterable)
default List<String>	linesOf(File actual) Delegate call to Assertions.linesOf(File)
default List<String>	linesOf(File actual, Charset arg1) Delegate call to Assertions.linesOf(File,Charset)
default List<String>	linesOf(File file, String charsetName) Delegate call to Assertions.linesOf(File,String)
default <T> Not<T>	not(Condition<? super T> condition) Delegate call to Assertions.not(Condition)
default Offset<Double>	offset(Double value) Delegate call to Assertions.offset(Double)
default Offset<Float>	offset(Float value) Delegate call to Assertions.offset(Float)
default void	registerCustomDateFormat(DateFormat actual) Delegate call to Assertions.registerCustomDateFormat(DateFormat)
default void	registerCustomDateFormat(String actual) Delegate call to Assertions.registerCustomDateFormat(String)
default void	setAllowExtractingPrivateFields(boolean actual) Delegate call to Assertions.setAllowExtractingPrivateFields(boolean)
default void	setRemoveAssertJRelatedElementsFromStackTrace(boolean actual) Delegate call to Assertions.setRemoveAssertJRelatedElementsFromStackTrace(boolean)
default Tuple	tuple(Object... values) Delegate call to Assertions.tuple(Object[])
default void	useDefaultDateFormatsOnly() Delegate call to Assertions.useDefaultDateFormatsOnly()
default Offset<BigDecimal>	within(BigDecimal actual) Delegate call to Assertions.within(BigDecimal)
default Offset<Double>	within(Double actual) Delegate call to Assertions.within(Double)
default Offset<Float>	within(Float actual) Delegate call to Assertions.within(Float)

Method Detail

offset

default Offset<Float> offset(Float value)

Delegate call to Assertions.offset(Float)

offset

default Offset<Double> offset(Double value)

Delegate call to Assertions.offset(Double)

entry

default <K,V> MapEntry<K,V> entry(K key,
                                  V value)

Delegate call to Assertions.entry(Object, Object)

fail

default void fail(String failureMessage)

Delegate call to Assertions.fail(String)

fail

default void fail(String failureMessage,
                  Throwable realCause)

Delegate call to Assertions.fail(String,Throwable)

not

default <T> Not<T> not(Condition<? super T> condition)

Delegate call to Assertions.not(Condition)

allOf

default <T> Condition<T> allOf(Iterable<? extends Condition<? super T>> conditions)

Delegate call to Assertions.allOf(Iterable)

allOf

default <T> Condition<T> allOf(Condition<? super T>... conditions)

Delegate call to Assertions.allOf(Condition[])

assertThat

default <T> AbstractObjectArrayAssert<?,T> assertThat(T[] actual)

Delegate call to org.assertj.core.api.Assertions#assertThat(T[])

assertThat

default <T extends AssertDelegateTarget> T assertThat(T assertion)

Delegate call to Assertions.assertThat(AssertDelegateTarget)

assertThat

default <K,V> MapAssert<K,V> assertThat(Map<K,V> actual)

Delegate call to Assertions.assertThat(Map)

assertThat

default AbstractShortAssert<?> assertThat(short actual)

Delegate call to Assertions.assertThat(short)

assertThat

default AbstractLongAssert<?> assertThat(long actual)

Delegate call to Assertions.assertThat(long)

assertThat

default AbstractLongAssert<?> assertThat(Long actual)

Delegate call to Assertions.assertThat(Long)

assertThat

default AbstractLongArrayAssert<?> assertThat(long[] actual)

Delegate call to Assertions.assertThat(long[])

assertThat

default <T> AbstractObjectAssert<?,T> assertThat(T actual)

Delegate call to org.assertj.core.api.Assertions#assertThat(T)

assertThat

default AbstractCharSequenceAssert<?,String> assertThat(String actual)

Delegate call to Assertions.assertThat(String)

assertThat

default AbstractDateAssert<?> assertThat(Date actual)

Delegate call to Assertions.assertThat(Date)

assertThat

default AbstractThrowableAssert<?,? extends Throwable> assertThat(Throwable actual)

Delegate call to Assertions.assertThat(Throwable)

assertThat

default AbstractBigDecimalAssert<?> assertThat(BigDecimal actual)

Delegate call to Assertions.assertThat(BigDecimal)

assertThat

default AbstractCharSequenceAssert<?,? extends CharSequence> assertThat(CharSequence actual)

Delegate call to Assertions.assertThat(CharSequence)

assertThat

default AbstractShortArrayAssert<?> assertThat(short[] actual)

Delegate call to Assertions.assertThat(short[])

assertThat

default AbstractShortAssert<?> assertThat(Short actual)

Delegate call to Assertions.assertThat(Short)

assertThat

default AbstractClassAssert<?> assertThat(Class<?> actual)

Delegate call to Assertions.assertThat(Class)

assertThat

default AbstractCharacterAssert<?> assertThat(Character actual)

Delegate call to Assertions.assertThat(Character)

assertThat

default AbstractCharArrayAssert<?> assertThat(char[] actual)

Delegate call to Assertions.assertThat(char[])

assertThat

default AbstractCharacterAssert<?> assertThat(char actual)

Delegate call to Assertions.assertThat(char)

assertThat

default <T extends Comparable<? super T>> AbstractComparableAssert<?,T> assertThat(T actual)

Delegate call to Assertions.assertThat(Comparable)

assertThat

default <T> IterableAssert<T> assertThat(Iterable<? extends T> actual)

Delegate call to Assertions.assertThat(Iterable)

assertThat

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)

Delegate call to Assertions.assertThat(Iterable, AssertFactory)

assertThat

default <T> IterableAssert<T> assertThat(Iterator<? extends T> actual)

Delegate call to Assertions.assertThat(Iterator)

assertThat

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)

Delegate call to Assertions.assertThat(Iterable, Class)

assertThat

default AbstractBooleanAssert<?> assertThat(Boolean actual)

Delegate call to Assertions.assertThat(Boolean)

assertThat

default AbstractBooleanArrayAssert<?> assertThat(boolean[] actual)

Delegate call to Assertions.assertThat(boolean)

assertThat

default AbstractByteAssert<?> assertThat(byte actual)

Delegate call to Assertions.assertThat(byte)

assertThat

default AbstractByteAssert<?> assertThat(Byte actual)

Delegate call to Assertions.assertThat(Byte)

assertThat

default AbstractByteArrayAssert<?> assertThat(byte[] actual)

Delegate call to Assertions.assertThat(byte[])

assertThat

default AbstractBooleanAssert<?> assertThat(boolean actual)

Delegate call to Assertions.assertThat(boolean)

assertThat

default AbstractFloatAssert<?> assertThat(float actual)

Delegate call to Assertions.assertThat(float)

assertThat

default AbstractInputStreamAssert<?,? extends InputStream> assertThat(InputStream actual)

Delegate call to Assertions.assertThat(InputStream)

assertThat

default AbstractFileAssert<?> assertThat(File actual)

Delegate call to Assertions.assertThat(File)

assertThat

default AbstractPathAssert<?> assertThat(Path actual)

Delegate call to Assertions.assertThat(Path)

assertThat

default AbstractIntArrayAssert<?> assertThat(int[] actual)

Delegate call to Assertions.assertThat(int[])

assertThat

default AbstractFloatAssert<?> assertThat(Float actual)

Delegate call to Assertions.assertThat(Float)

assertThat

default AbstractIntegerAssert<?> assertThat(int actual)

Delegate call to Assertions.assertThat(int)

assertThat

default AbstractFloatArrayAssert<?> assertThat(float[] actual)

Delegate call to Assertions.assertThat(float[])

assertThat

default AbstractIntegerAssert<?> assertThat(Integer actual)

Delegate call to Assertions.assertThat(Integer)

assertThat

default AbstractDoubleAssert<?> assertThat(double actual)

Delegate call to Assertions.assertThat(double)

assertThat

default AbstractDoubleAssert<?> assertThat(Double actual)

Delegate call to Assertions.assertThat(Double)

assertThat

default <T> ListAssert<? extends T> assertThat(List<? extends T> actual)

Delegate call to Assertions.assertThat(List)

assertThat

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)

Delegate call to Assertions.assertThat(List, Class) )}

assertThat

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)

Delegate call to Assertions.assertThat(List, AssertFactory) )}

assertThat

default <T> AbstractListAssert<?,? extends List<? extends T>,T,ObjectAssert<T>> assertThat(Stream<? extends T> actual)

Delegate call to Assertions.assertThat(List)

assertThat

default AbstractDoubleArrayAssert<?> assertThat(double[] actual)

Delegate call to Assertions.assertThat(double[])

extractProperty

default Properties<Object> extractProperty(String propertyName)

Delegate call to Assertions.extractProperty(String)

extractProperty

default <T> Properties<T> extractProperty(String propertyName,
                                          Class<T> propertyType)

Delegate call to Assertions.extractProperty(String,Class)

tuple

default Tuple tuple(Object... values)

Delegate call to Assertions.tuple(Object[])

atIndex

default Index atIndex(int actual)

Delegate call to Assertions.atIndex(int)

within

default Offset<Double> within(Double actual)

Delegate call to Assertions.within(Double)

within

default Offset<BigDecimal> within(BigDecimal actual)

Delegate call to Assertions.within(BigDecimal)

within

default Offset<Float> within(Float actual)

Delegate call to Assertions.within(Float)

anyOf

default <T> Condition<T> anyOf(Iterable<? extends Condition<? super T>> conditions)

Delegate call to Assertions.anyOf(Iterable)

anyOf

default <T> Condition<T> anyOf(Condition<? super T>... conditions)

Delegate call to Assertions.anyOf(Condition[])

doesNotHave

default <T> DoesNotHave<T> doesNotHave(Condition<? super T> condition)

Delegate call to Assertions.doesNotHave(Condition)

contentOf

default String contentOf(File file,
                         String charsetName)

Delegate call to Assertions.contentOf(File,String)

contentOf

default String contentOf(File actual)

Delegate call to Assertions.contentOf(File)

contentOf

default String contentOf(File file,
                         Charset charset)

Delegate call to Assertions.contentOf(File,Charset)

linesOf

default List<String> linesOf(File actual)

Delegate call to Assertions.linesOf(File)

linesOf

default List<String> linesOf(File file,
                             String charsetName)

Delegate call to Assertions.linesOf(File,String)

linesOf

default List<String> linesOf(File actual,
                             Charset arg1)

Delegate call to Assertions.linesOf(File,Charset)

setRemoveAssertJRelatedElementsFromStackTrace

default void setRemoveAssertJRelatedElementsFromStackTrace(boolean actual)

Delegate call to Assertions.setRemoveAssertJRelatedElementsFromStackTrace(boolean)

failBecauseExceptionWasNotThrown

default void failBecauseExceptionWasNotThrown(Class<? extends Throwable> exceptionClass)

Delegate call to Assertions.failBecauseExceptionWasNotThrown(java.lang.Class<? extends java.lang.Throwable>)

setAllowExtractingPrivateFields

default void setAllowExtractingPrivateFields(boolean actual)

Delegate call to Assertions.setAllowExtractingPrivateFields(boolean)

registerCustomDateFormat

default void registerCustomDateFormat(DateFormat actual)

Delegate call to Assertions.registerCustomDateFormat(DateFormat)

registerCustomDateFormat

default void registerCustomDateFormat(String actual)

Delegate call to Assertions.registerCustomDateFormat(String)

useDefaultDateFormatsOnly

default void useDefaultDateFormatsOnly()

Delegate call to Assertions.useDefaultDateFormatsOnly()

assertThat

default AbstractZonedDateTimeAssert<?> assertThat(ZonedDateTime actual)

Delegate call to Assertions.assertThat(ZonedDateTime)

assertThat

default <T> CompletableFutureAssert<T> assertThat(CompletableFuture<T> future)

Delegate call to Assertions.assertThat(CompletableFuture)

assertThat

default <T> OptionalAssert<T> assertThat(Optional<T> optional)

Delegate call to Assertions.assertThat(Optional)

assertThat

default OptionalDoubleAssert assertThat(OptionalDouble optional)

Delegate call to Assertions.assertThat(java.util.OptionalDouble)

assertThat

default OptionalIntAssert assertThat(OptionalInt optional)

Delegate call to Assertions.assertThat(java.util.OptionalInt)

assertThat

default OptionalLongAssert assertThat(OptionalLong optional)

Delegate call to Assertions.assertThat(java.util.OptionalLong)

assertThat

default AbstractLocalDateTimeAssert<?> assertThat(LocalDateTime localDateTime)

Delegate call to Assertions.assertThat(LocalDateTime)

assertThat

default AbstractLocalDateAssert<?> assertThat(LocalDate localDate)

Delegate call to Assertions.assertThat(LocalDate)

assertThat

default AbstractLocalTimeAssert<?> assertThat(LocalTime localTime)

Delegate call to Assertions.assertThat(LocalTime)

assertThat

default AbstractOffsetTimeAssert<?> assertThat(OffsetTime offsetTime)

Delegate call to Assertions.assertThat(OffsetTime)

assertThat

default AbstractOffsetDateTimeAssert<?> assertThat(OffsetDateTime offsetDateTime)

Delegate call to Assertions.assertThat(OffsetDateTime)

assertThatThrownBy

default AbstractThrowableAssert<?,? extends Throwable> assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)

Delegate call to org.assertj.core.api.Assertions#assertThatThrownBy(ThrowingCallable)

catchThrowable

default Throwable catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)

Delegate call to org.assertj.core.api.Assertions#catchThrowable(ThrowingCallable)

assertThatExceptionOfType

default <T extends Throwable> ThrowableTypeAssert<T> 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.

Example:

 assertThatExceptionOfType(IOException.class).isThrownBy(() -> { throw new IOException("boom!"); })
                                       .withMessage("boom!"); 

This method is more or less the same of #assertThatThrownBy(ThrowingCallable) but in a more natural way.

Parameters:

actual - the actual value.

Returns:

the created ThrowableTypeAssert.

assertThat

default <T> PredicateAssert<T> assertThat(Predicate<T> actual)

Delegate call to Assertions.assertThat(Predicate)

assertThat

default IntPredicateAssert assertThat(IntPredicate actual)

Delegate call to Assertions.assertThat(IntPredicate)

assertThat

default LongPredicateAssert assertThat(LongPredicate actual)

Delegate call to Assertions.assertThat(LongPredicate)

assertThat

default DoublePredicateAssert assertThat(DoublePredicate actual)

Delegate call to Assertions.assertThat(DoublePredicate)

assertThat

default AbstractUrlAssert<?> assertThat(URL actual)

Delegate call to Assertions.assertThat(URL)

assertThat

default AbstractUriAssert<?> assertThat(URI actual)

Delegate call to Assertions.assertThat(URI)

assertThat

default <T> T assertThat(AssertProvider<T> component)

Delegate call to Assertions.assertThat(AssertProvider)

filter

default <E> Filters<E> filter(E[] array)

Delegate call to org.assertj.core.api.Assertions#filter(E[])

filter

default <E> Filters<E> filter(Iterable<E> iterableToFilter)

Delegate call to Assertions.filter(Iterable)