Package 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/

Method Summary

Modifier and Type	Method	Description
default <T> Condition<T>	allOf(java.lang.Iterable<? extends Condition<? super T>> conditions)	Delegate call to Assertions.allOf(Iterable)
default <T> Condition<T>	allOf(Condition<? super T>... conditions)	Delegate call to Assertions.allOf(Condition[])
default <T> Condition<T>	anyOf(java.lang.Iterable<? extends Condition<? super T>> conditions)	Delegate call to Assertions.anyOf(Iterable)
default <T> Condition<T>	anyOf(Condition<? super T>... conditions)	Delegate call to Assertions.anyOf(Condition[])
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 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 AbstractDoubleAssert<?>	assertThat(double actual)	Delegate call to Assertions.assertThat(double)
default AbstractDoubleArrayAssert<?>	assertThat(double[] actual)	Delegate call to Assertions.assertThat(double[])
default AbstractFloatAssert<?>	assertThat(float actual)	Delegate call to Assertions.assertThat(float)
default AbstractFloatArrayAssert<?>	assertThat(float[] actual)	Delegate call to Assertions.assertThat(float[])
default AbstractIntegerAssert<?>	assertThat(int actual)	Delegate call to Assertions.assertThat(int)
default AbstractIntArrayAssert<?>	assertThat(int[] actual)	Delegate call to Assertions.assertThat(int[])
default AbstractLongAssert<?>	assertThat(long actual)	Delegate call to Assertions.assertThat(long)
default AbstractLongArrayAssert<?>	assertThat(long[] actual)	Delegate call to Assertions.assertThat(long[])
default AbstractShortAssert<?>	assertThat(short actual)	Delegate call to Assertions.assertThat(short)
default AbstractShortArrayAssert<?>	assertThat(short[] actual)	Delegate call to Assertions.assertThat(short[])
default <ACTUAL extends java.lang.Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	assertThat(ACTUAL actual, java.lang.Class<ELEMENT_ASSERT> assertClass)	Delegate call to Assertions.assertThat(Iterable, Class)
default AbstractFileAssert<?>	assertThat(java.io.File actual)	Delegate call to Assertions.assertThat(File)
default AbstractInputStreamAssert<?,? extends java.io.InputStream>	assertThat(java.io.InputStream actual)	Delegate call to Assertions.assertThat(InputStream)
default AbstractBooleanAssert<?>	assertThat(java.lang.Boolean actual)	Delegate call to Assertions.assertThat(Boolean)
default AbstractByteAssert<?>	assertThat(java.lang.Byte actual)	Delegate call to Assertions.assertThat(Byte)
default AbstractCharacterAssert<?>	assertThat(java.lang.Character actual)	Delegate call to Assertions.assertThat(Character)
default AbstractCharSequenceAssert<?,? extends java.lang.CharSequence>	assertThat(java.lang.CharSequence actual)	Delegate call to Assertions.assertThat(CharSequence)
default AbstractClassAssert<?>	assertThat(java.lang.Class<?> actual)	Delegate call to Assertions.assertThat(Class)
default AbstractDoubleAssert<?>	assertThat(java.lang.Double actual)	Delegate call to Assertions.assertThat(Double)
default AbstractFloatAssert<?>	assertThat(java.lang.Float actual)	Delegate call to Assertions.assertThat(Float)
default AbstractIntegerAssert<?>	assertThat(java.lang.Integer actual)	Delegate call to Assertions.assertThat(Integer)
default <ACTUAL extends java.lang.Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	assertThat(java.lang.Iterable<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)	Delegate call to Assertions.assertThat(Iterable, AssertFactory)
default <T> IterableAssert<T>	assertThat(java.lang.Iterable<? extends T> actual)	Delegate call to Assertions.assertThat(Iterable)
default AbstractLongAssert<?>	assertThat(java.lang.Long actual)	Delegate call to Assertions.assertThat(Long)
default AbstractShortAssert<?>	assertThat(java.lang.Short actual)	Delegate call to Assertions.assertThat(Short)
default AbstractCharSequenceAssert<?,java.lang.String>	assertThat(java.lang.String actual)	Delegate call to Assertions.assertThat(String)
default AbstractThrowableAssert<?,? extends java.lang.Throwable>	assertThat(java.lang.Throwable actual)	Delegate call to Assertions.assertThat(Throwable)
default AbstractBigDecimalAssert<?>	assertThat(java.math.BigDecimal actual)	Delegate call to Assertions.assertThat(BigDecimal)
default AbstractBigIntegerAssert<?>	assertThat(java.math.BigInteger actual)	Creates a new instance of BigIntegerAssert.
default AbstractUriAssert<?>	assertThat(java.net.URI actual)	Delegate call to Assertions.assertThat(URI)
default AbstractUrlAssert<?>	assertThat(java.net.URL actual)	Delegate call to Assertions.assertThat(URL)
default AbstractPathAssert<?>	assertThat(java.nio.file.Path actual)	Delegate call to Assertions.assertThat(Path)
default AbstractInstantAssert<?>	assertThat(java.time.Instant actual)	Delegate call to Assertions.assertThat(java.time.Instant)
default AbstractLocalDateAssert<?>	assertThat(java.time.LocalDate localDate)	Delegate call to Assertions.assertThat(LocalDate)
default AbstractLocalDateTimeAssert<?>	assertThat(java.time.LocalDateTime localDateTime)	Delegate call to Assertions.assertThat(LocalDateTime)
default AbstractLocalTimeAssert<?>	assertThat(java.time.LocalTime localTime)	Delegate call to Assertions.assertThat(LocalTime)
default AbstractOffsetDateTimeAssert<?>	assertThat(java.time.OffsetDateTime offsetDateTime)	Delegate call to Assertions.assertThat(OffsetDateTime)
default AbstractOffsetTimeAssert<?>	assertThat(java.time.OffsetTime offsetTime)	Delegate call to Assertions.assertThat(OffsetTime)
default AbstractZonedDateTimeAssert<?>	assertThat(java.time.ZonedDateTime actual)	Delegate call to Assertions.assertThat(ZonedDateTime)
default AtomicBooleanAssert	assertThat(java.util.concurrent.atomic.AtomicBoolean actual)	Create assertion for AtomicBoolean.
default AtomicIntegerAssert	assertThat(java.util.concurrent.atomic.AtomicInteger actual)	Create assertion for AtomicInteger.
default AtomicIntegerArrayAssert	assertThat(java.util.concurrent.atomic.AtomicIntegerArray actual)	Create int[] assertion for AtomicIntegerArray.
default <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>	assertThat(java.util.concurrent.atomic.AtomicIntegerFieldUpdater<OBJECT> actual)	Create assertion for AtomicIntegerFieldUpdater.
default AtomicLongAssert	assertThat(java.util.concurrent.atomic.AtomicLong actual)	Create assertion for AtomicLong.
default AtomicLongArrayAssert	assertThat(java.util.concurrent.atomic.AtomicLongArray actual)	Create assertion for AtomicLongArray.
default <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>	assertThat(java.util.concurrent.atomic.AtomicLongFieldUpdater<OBJECT> actual)	Create assertion for AtomicLongFieldUpdater.
default <VALUE> AtomicMarkableReferenceAssert<VALUE>	assertThat(java.util.concurrent.atomic.AtomicMarkableReference<VALUE> actual)	Create assertion for AtomicMarkableReference.
default <VALUE> AtomicReferenceAssert<VALUE>	assertThat(java.util.concurrent.atomic.AtomicReference<VALUE> actual)	Create assertion for AtomicReference.
default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	assertThat(java.util.concurrent.atomic.AtomicReferenceArray<ELEMENT> actual)	Create assertion for AtomicReferenceArray.
default <FIELD,OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT>	assertThat(java.util.concurrent.atomic.AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)	Create assertion for AtomicReferenceFieldUpdater.
default <VALUE> AtomicStampedReferenceAssert<VALUE>	assertThat(java.util.concurrent.atomic.AtomicStampedReference<VALUE> actual)	Create assertion for AtomicStampedReference.
default <RESULT> CompletableFutureAssert<RESULT>	assertThat(java.util.concurrent.CompletableFuture<RESULT> future)	Delegate call to Assertions.assertThat(CompletableFuture)
default <RESULT> AbstractFutureAssert<?,? extends java.util.concurrent.Future<? extends RESULT>,RESULT>	assertThat(java.util.concurrent.Future<RESULT> actual)	Delegate call to Assertions.assertThat(Future)
default AbstractDateAssert<?>	assertThat(java.util.Date actual)	Delegate call to Assertions.assertThat(Date)
default DoublePredicateAssert	assertThat(java.util.function.DoublePredicate actual)	Delegate call to Assertions.assertThat(DoublePredicate)
default IntPredicateAssert	assertThat(java.util.function.IntPredicate actual)	Delegate call to Assertions.assertThat(IntPredicate)
default LongPredicateAssert	assertThat(java.util.function.LongPredicate actual)	Delegate call to Assertions.assertThat(LongPredicate)
default <T> PredicateAssert<T>	assertThat(java.util.function.Predicate<T> actual)	Delegate call to Assertions.assertThat(Predicate)
default <T> IterableAssert<T>	assertThat(java.util.Iterator<? extends T> actual)	Delegate call to Assertions.assertThat(Iterator)
default <ELEMENT,ACTUAL extends java.util.List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	assertThat(java.util.List<? extends ELEMENT> actual, java.lang.Class<ELEMENT_ASSERT> assertClass)	Delegate call to Assertions.assertThat(List, Class) )}
default <ACTUAL extends java.util.List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	assertThat(java.util.List<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)	Delegate call to Assertions.assertThat(List, AssertFactory) )}
default <T> ListAssert<? extends T>	assertThat(java.util.List<? extends T> actual)	Delegate call to Assertions.assertThat(List)
default <K,V> MapAssert<K,V>	assertThat(java.util.Map<K,V> actual)	Delegate call to Assertions.assertThat(Map)
default <VALUE> OptionalAssert<VALUE>	assertThat(java.util.Optional<VALUE> optional)	Delegate call to Assertions.assertThat(Optional)
default OptionalDoubleAssert	assertThat(java.util.OptionalDouble optional)	Delegate call to Assertions.assertThat(java.util.OptionalDouble)
default OptionalIntAssert	assertThat(java.util.OptionalInt optional)	Delegate call to Assertions.assertThat(java.util.OptionalInt)
default OptionalLongAssert	assertThat(java.util.OptionalLong optional)	Delegate call to Assertions.assertThat(java.util.OptionalLong)
default <ELEMENT,STREAM extends java.util.stream.BaseStream<ELEMENT,STREAM>> AbstractListAssert<?,? extends java.util.List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>	assertThat(java.util.stream.BaseStream<? extends ELEMENT,STREAM> actual)	Delegate call to Assertions.assertThat(List)
default <T> T	assertThat(AssertProvider<T> component)	Delegate call to Assertions.assertThat(AssertProvider)
default <T extends AssertDelegateTarget> T	assertThat(T assertion)	Delegate call to Assertions.assertThat(AssertDelegateTarget)
default <T> AbstractObjectArrayAssert<?,T>	assertThat(T[] actual)	Delegate call to Assertions.assertThat(Object[])
default AbstractThrowableAssert<?,? extends java.lang.Throwable>	assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
default <T extends java.lang.Throwable> ThrowableTypeAssert<T>	assertThatExceptionOfType(java.lang.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 java.lang.Throwable>	assertThatThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)	Delegate call to Assertions.assertThatThrownBy(ThrowableAssert.ThrowingCallable)
default Index	atIndex(int actual)	Delegate call to Assertions.atIndex(int)
default java.lang.Throwable	catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)	Delegate call to Assertions.catchThrowable(ThrowableAssert.ThrowingCallable)
default java.lang.String	contentOf(java.io.File actual)	Delegate call to Assertions.contentOf(File)
default java.lang.String	contentOf(java.io.File file, java.lang.String charsetName)	Delegate call to Assertions.contentOf(File,String)
default java.lang.String	contentOf(java.io.File file, java.nio.charset.Charset charset)	Delegate call to Assertions.contentOf(File,Charset)
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<java.lang.Object>	extractProperty(java.lang.String propertyName)	Delegate call to Assertions.extractProperty(String)
default <T> Properties<T>	extractProperty(java.lang.String propertyName, java.lang.Class<T> propertyType)	Delegate call to Assertions.extractProperty(String,Class)
default void	fail(java.lang.String failureMessage)	Delegate call to Assertions.fail(String)
default void	fail(java.lang.String failureMessage, java.lang.Throwable realCause)	Delegate call to Assertions.fail(String,Throwable)
default void	failBecauseExceptionWasNotThrown(java.lang.Class<? extends java.lang.Throwable> exceptionClass)	Delegate call to Assertions.failBecauseExceptionWasNotThrown(java.lang.Class<? extends java.lang.Throwable>)
default <E> Filters<E>	filter(E[] array)	Delegate call to Assertions.filter(Object[])
default <E> Filters<E>	filter(java.lang.Iterable<E> iterableToFilter)	Delegate call to Assertions.filter(Iterable)
default java.util.List<java.lang.String>	linesOf(java.io.File actual)	Delegate call to Assertions.linesOf(File)
default java.util.List<java.lang.String>	linesOf(java.io.File file, java.lang.String charsetName)	Delegate call to Assertions.linesOf(File,String)
default java.util.List<java.lang.String>	linesOf(java.io.File actual, java.nio.charset.Charset arg1)	Delegate call to Assertions.linesOf(File,Charset)
default <T> Not<T>	not(Condition<? super T> condition)	Delegate call to Assertions.not(Condition)
default Offset<java.lang.Double>	offset(java.lang.Double value)	Delegate call to Assertions.offset(Double)
default Offset<java.lang.Float>	offset(java.lang.Float value)	Delegate call to Assertions.offset(Float)
default void	registerCustomDateFormat(java.lang.String actual)	Delegate call to Assertions.registerCustomDateFormat(String)
default void	registerCustomDateFormat(java.text.DateFormat actual)	Delegate call to Assertions.registerCustomDateFormat(DateFormat)
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(java.lang.Object... values)	Delegate call to Assertions.tuple(Object[])
default void	useDefaultDateFormatsOnly()	Delegate call to Assertions.useDefaultDateFormatsOnly()
default Offset<java.lang.Double>	within(java.lang.Double actual)	Delegate call to Assertions.within(Double)
default Offset<java.lang.Float>	within(java.lang.Float actual)	Delegate call to Assertions.within(Float)
default Offset<java.math.BigDecimal>	within(java.math.BigDecimal actual)	Delegate call to Assertions.within(BigDecimal)

Method Detail

offset

default Offset<java.lang.Float> offset(java.lang.Float value)

Delegate call to Assertions.offset(Float)

offset

default Offset<java.lang.Double> offset(java.lang.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(java.lang.String failureMessage)

Delegate call to Assertions.fail(String)

fail

default void fail(java.lang.String failureMessage,
                  java.lang.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(java.lang.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 Assertions.assertThat(Object[])

assertThat

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

Delegate call to Assertions.assertThat(AssertDelegateTarget)

assertThat

default <K,V> MapAssert<K,V> assertThat(java.util.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(java.lang.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 Assertions.assertThat(Object)

assertThat

default AbstractCharSequenceAssert<?,java.lang.String> assertThat(java.lang.String actual)

Delegate call to Assertions.assertThat(String)

assertThat

default AbstractDateAssert<?> assertThat(java.util.Date actual)

Delegate call to Assertions.assertThat(Date)

assertThat

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

Delegate call to Assertions.assertThat(Throwable)

assertThat

default AbstractBigDecimalAssert<?> assertThat(java.math.BigDecimal actual)

Delegate call to Assertions.assertThat(BigDecimal)

assertThat

default AbstractBigIntegerAssert<?> assertThat(java.math.BigInteger actual)

Creates a new instance of BigIntegerAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

Since:

2.7.0 / 3.7.0

assertThat

default AtomicBooleanAssert assertThat(java.util.concurrent.atomic.AtomicBoolean actual)

Create assertion for AtomicBoolean.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default AtomicIntegerAssert assertThat(java.util.concurrent.atomic.AtomicInteger actual)

Create assertion for AtomicInteger.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default AtomicIntegerArrayAssert assertThat(java.util.concurrent.atomic.AtomicIntegerArray actual)

Create int[] assertion for AtomicIntegerArray.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> assertThat(java.util.concurrent.atomic.AtomicIntegerFieldUpdater<OBJECT> actual)

Create assertion for AtomicIntegerFieldUpdater.

Type Parameters:

OBJECT - the type of the object holding the updatable field.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default AtomicLongAssert assertThat(java.util.concurrent.atomic.AtomicLong actual)

Create assertion for AtomicLong.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default AtomicLongArrayAssert assertThat(java.util.concurrent.atomic.AtomicLongArray actual)

Create assertion for AtomicLongArray.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> assertThat(java.util.concurrent.atomic.AtomicLongFieldUpdater<OBJECT> actual)

Create assertion for AtomicLongFieldUpdater.

Type Parameters:

OBJECT - the type of the object holding the updatable field.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default <VALUE> AtomicReferenceAssert<VALUE> assertThat(java.util.concurrent.atomic.AtomicReference<VALUE> actual)

Create assertion for AtomicReference.

Type Parameters:

VALUE - the type of the value contained in the AtomicReference.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> assertThat(java.util.concurrent.atomic.AtomicReferenceArray<ELEMENT> actual)

Create assertion for AtomicReferenceArray.

Type Parameters:

ELEMENT - the type of the value contained in the AtomicReferenceArray.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default <FIELD,OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> assertThat(java.util.concurrent.atomic.AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)

Create assertion for AtomicReferenceFieldUpdater.

Type Parameters:

FIELD - the type of the field which gets updated by the AtomicReferenceFieldUpdater.

OBJECT - the type of the object holding the updatable field.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default <VALUE> AtomicMarkableReferenceAssert<VALUE> assertThat(java.util.concurrent.atomic.AtomicMarkableReference<VALUE> actual)

Create assertion for AtomicMarkableReference.

Type Parameters:

VALUE - the type of the value contained in the AtomicMarkableReference.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

default <VALUE> AtomicStampedReferenceAssert<VALUE> assertThat(java.util.concurrent.atomic.AtomicStampedReference<VALUE> actual)

Create assertion for AtomicStampedReference.

Type Parameters:

VALUE - the type of the value contained in the AtomicStampedReference.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

assertThat

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

Delegate call to Assertions.assertThat(CharSequence)

assertThat

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

Delegate call to Assertions.assertThat(short[])

assertThat

default AbstractShortAssert<?> assertThat(java.lang.Short actual)

Delegate call to Assertions.assertThat(Short)

assertThat

default AbstractClassAssert<?> assertThat(java.lang.Class<?> actual)

Delegate call to Assertions.assertThat(Class)

assertThat

default AbstractCharacterAssert<?> assertThat(java.lang.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 java.lang.Comparable<? super T>> AbstractComparableAssert<?,T> assertThat(T actual)

Delegate call to Assertions.assertThat(Comparable)

assertThat

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

Delegate call to Assertions.assertThat(Iterable)

assertThat

default <ACTUAL extends java.lang.Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(java.lang.Iterable<? extends ELEMENT> actual,
                                                                                                                                                                                                                                                         AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)

Delegate call to Assertions.assertThat(Iterable, AssertFactory)

assertThat

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

Delegate call to Assertions.assertThat(Iterator)

assertThat

default <ACTUAL extends java.lang.Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(ACTUAL actual,
                                                                                                                                                                                                                                                       java.lang.Class<ELEMENT_ASSERT> assertClass)

Delegate call to Assertions.assertThat(Iterable, Class)

assertThat

default AbstractBooleanAssert<?> assertThat(java.lang.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(java.lang.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 java.io.InputStream> assertThat(java.io.InputStream actual)

Delegate call to Assertions.assertThat(InputStream)

assertThat

default AbstractFileAssert<?> assertThat(java.io.File actual)

Delegate call to Assertions.assertThat(File)

assertThat

default <RESULT> AbstractFutureAssert<?,? extends java.util.concurrent.Future<? extends RESULT>,RESULT> assertThat(java.util.concurrent.Future<RESULT> actual)

Delegate call to Assertions.assertThat(Future)

Since:

3.7.0

assertThat

default AbstractPathAssert<?> assertThat(java.nio.file.Path actual)

Delegate call to Assertions.assertThat(Path)

assertThat

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

Delegate call to Assertions.assertThat(int[])

assertThat

default AbstractFloatAssert<?> assertThat(java.lang.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(java.lang.Integer actual)

Delegate call to Assertions.assertThat(Integer)

assertThat

default AbstractDoubleAssert<?> assertThat(double actual)

Delegate call to Assertions.assertThat(double)

assertThat

default AbstractDoubleAssert<?> assertThat(java.lang.Double actual)

Delegate call to Assertions.assertThat(Double)

assertThat

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

Delegate call to Assertions.assertThat(List)

assertThat

default <ELEMENT,ACTUAL extends java.util.List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(java.util.List<? extends ELEMENT> actual,
                                                                                                                                                                                                                                               java.lang.Class<ELEMENT_ASSERT> assertClass)

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

assertThat

default <ACTUAL extends java.util.List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(java.util.List<? extends ELEMENT> actual,
                                                                                                                                                                                                                                                 AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)

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

assertThat

default <ELEMENT,STREAM extends java.util.stream.BaseStream<ELEMENT,STREAM>> AbstractListAssert<?,? extends java.util.List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> assertThat(java.util.stream.BaseStream<? extends ELEMENT,STREAM> actual)

Delegate call to Assertions.assertThat(List)

assertThat

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

Delegate call to Assertions.assertThat(double[])

extractProperty

default Properties<java.lang.Object> extractProperty(java.lang.String propertyName)

Delegate call to Assertions.extractProperty(String)

extractProperty

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

Delegate call to Assertions.extractProperty(String,Class)

tuple

default Tuple tuple(java.lang.Object... values)

Delegate call to Assertions.tuple(Object[])

atIndex

default Index atIndex(int actual)

Delegate call to Assertions.atIndex(int)

within

default Offset<java.lang.Double> within(java.lang.Double actual)

Delegate call to Assertions.within(Double)

within

default Offset<java.math.BigDecimal> within(java.math.BigDecimal actual)

Delegate call to Assertions.within(BigDecimal)

within

default Offset<java.lang.Float> within(java.lang.Float actual)

Delegate call to Assertions.within(Float)

anyOf

default <T> Condition<T> anyOf(java.lang.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 java.lang.String contentOf(java.io.File file,
                                   java.lang.String charsetName)

Delegate call to Assertions.contentOf(File,String)

contentOf

default java.lang.String contentOf(java.io.File actual)

Delegate call to Assertions.contentOf(File)

contentOf

default java.lang.String contentOf(java.io.File file,
                                   java.nio.charset.Charset charset)

Delegate call to Assertions.contentOf(File,Charset)

linesOf

default java.util.List<java.lang.String> linesOf(java.io.File actual)

Delegate call to Assertions.linesOf(File)

linesOf

default java.util.List<java.lang.String> linesOf(java.io.File file,
                                                 java.lang.String charsetName)

Delegate call to Assertions.linesOf(File,String)

linesOf

default java.util.List<java.lang.String> linesOf(java.io.File actual,
                                                 java.nio.charset.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(java.lang.Class<? extends java.lang.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(java.text.DateFormat actual)

Delegate call to Assertions.registerCustomDateFormat(DateFormat)

registerCustomDateFormat

default void registerCustomDateFormat(java.lang.String actual)

Delegate call to Assertions.registerCustomDateFormat(String)

useDefaultDateFormatsOnly

default void useDefaultDateFormatsOnly()

Delegate call to Assertions.useDefaultDateFormatsOnly()

assertThat

default AbstractZonedDateTimeAssert<?> assertThat(java.time.ZonedDateTime actual)

Delegate call to Assertions.assertThat(ZonedDateTime)

assertThat

default <RESULT> CompletableFutureAssert<RESULT> assertThat(java.util.concurrent.CompletableFuture<RESULT> future)

Delegate call to Assertions.assertThat(CompletableFuture)

assertThat

default <VALUE> OptionalAssert<VALUE> assertThat(java.util.Optional<VALUE> optional)

Delegate call to Assertions.assertThat(Optional)

assertThat

default OptionalDoubleAssert assertThat(java.util.OptionalDouble optional)

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

assertThat

default OptionalIntAssert assertThat(java.util.OptionalInt optional)

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

assertThat

default OptionalLongAssert assertThat(java.util.OptionalLong optional)

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

assertThat

default AbstractLocalDateTimeAssert<?> assertThat(java.time.LocalDateTime localDateTime)

Delegate call to Assertions.assertThat(LocalDateTime)

assertThat

default AbstractLocalDateAssert<?> assertThat(java.time.LocalDate localDate)

Delegate call to Assertions.assertThat(LocalDate)

assertThat

default AbstractLocalTimeAssert<?> assertThat(java.time.LocalTime localTime)

Delegate call to Assertions.assertThat(LocalTime)

assertThat

default AbstractInstantAssert<?> assertThat(java.time.Instant actual)

Delegate call to Assertions.assertThat(java.time.Instant)

Since:

3.7.0

assertThat

default AbstractOffsetTimeAssert<?> assertThat(java.time.OffsetTime offsetTime)

Delegate call to Assertions.assertThat(OffsetTime)

assertThat

default AbstractOffsetDateTimeAssert<?> assertThat(java.time.OffsetDateTime offsetDateTime)

Delegate call to Assertions.assertThat(OffsetDateTime)

assertThatThrownBy

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

Delegate call to Assertions.assertThatThrownBy(ThrowableAssert.ThrowingCallable)

assertThatCode

default AbstractThrowableAssert<?,? extends java.lang.Throwable> assertThatCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)

Allows to capture and then assert on a 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();

If the provided 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.
To use a test description, use catchThrowable(ThrowableAssert.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 :(

Parameters:

shouldRaiseOrNotThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.

Returns:

The captured exception or null if none was raised by the callable.

Since:

3.7.0

catchThrowable

default java.lang.Throwable catchThrowable(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)

Delegate call to Assertions.catchThrowable(ThrowableAssert.ThrowingCallable)

assertThatExceptionOfType

default <T extends java.lang.Throwable> ThrowableTypeAssert<T> assertThatExceptionOfType(java.lang.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(ThrowableAssert.ThrowingCallable) but in a more natural way.

Parameters:

exceptionType - the actual value.

Returns:

the created ThrowableTypeAssert.

assertThat

default <T> PredicateAssert<T> assertThat(java.util.function.Predicate<T> actual)

Delegate call to Assertions.assertThat(Predicate)

assertThat

default IntPredicateAssert assertThat(java.util.function.IntPredicate actual)

Delegate call to Assertions.assertThat(IntPredicate)

assertThat

default LongPredicateAssert assertThat(java.util.function.LongPredicate actual)

Delegate call to Assertions.assertThat(LongPredicate)

assertThat

default DoublePredicateAssert assertThat(java.util.function.DoublePredicate actual)

Delegate call to Assertions.assertThat(DoublePredicate)

assertThat

default AbstractUrlAssert<?> assertThat(java.net.URL actual)

Delegate call to Assertions.assertThat(URL)

assertThat

default AbstractUriAssert<?> assertThat(java.net.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 Assertions.filter(Object[])

filter

default <E> Filters<E> filter(java.lang.Iterable<E> iterableToFilter)

Delegate call to Assertions.filter(Iterable)