Package org.assertj.core.api

Class BDDAssertions

java.lang.Object

org.assertj.core.api.Assertions

org.assertj.core.api.BDDAssertions

public class BDDAssertions
extends Assertions

Behavior-driven development style entry point for assertion methods for different types. Each method in this class is a static factory for a type-specific assertion object.

The difference with the Assertions class is that entry point methods are named then instead of assertThat.

For example:

 @Test
 public void bdd_assertions_example() {
   //given
   List<BasketBallPlayer> bulls = new ArrayList<>();

   //when
   bulls.add(rose);
   bulls.add(noah);

   then(bulls).contains(rose, noah).doesNotContain(james);
 }

Author:

Alex Ruiz, Yvonne Wang, David DIDIER, Ted Young, Joel Costigliola, Matthieu Baechler, Mikhail Mazursky, Nicolas François, Julien Meddah, William Delanoue, Mariusz Smykula

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	BDDAssertions()	Creates a new BDDAssertions.

Method Summary

Modifier and Type	Method	Description
static AbstractBooleanAssert<?>	then(boolean actual)	Creates a new instance of BooleanAssert.
static AbstractBooleanArrayAssert<?>	then(boolean[] actual)	Creates a new instance of BooleanArrayAssert.
static AbstractByteAssert<?>	then(byte actual)	Creates a new instance of ByteAssert.
static AbstractByteArrayAssert<?>	then(byte[] actual)	Creates a new instance of ByteArrayAssert.
static AbstractCharacterAssert<?>	then(char actual)	Creates a new instance of CharacterAssert.
static AbstractCharArrayAssert<?>	then(char[] actual)	Creates a new instance of CharArrayAssert.
static AbstractDoubleAssert<?>	then(double actual)	Creates a new instance of DoubleAssert.
static AbstractDoubleArrayAssert<?>	then(double[] actual)	Creates a new instance of DoubleArrayAssert.
static AbstractFloatAssert<?>	then(float actual)	Creates a new instance of FloatAssert.
static AbstractFloatArrayAssert<?>	then(float[] actual)	Creates a new instance of FloatArrayAssert.
static AbstractIntegerAssert<?>	then(int actual)	Creates a new instance of IntegerAssert.
static AbstractIntArrayAssert<?>	then(int[] actual)	Creates a new instance of IntArrayAssert.
static AbstractLongAssert<?>	then(long actual)	Creates a new instance of LongAssert.
static AbstractLongArrayAssert<?>	then(long[] actual)	Creates a new instance of LongArrayAssert.
static AbstractShortAssert<?>	then(short actual)	Creates a new instance of ShortAssert.
static AbstractShortArrayAssert<?>	then(short[] actual)	Creates a new instance of ShortArrayAssert.
static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	then(ACTUAL actual, Class<ELEMENT_ASSERT> assertClass)	Creates a new instance of ClassBasedNavigableIterableAssert allowing to navigate to any Iterable element in order to perform assertions on it.
static AbstractFileAssert<?>	then(File actual)	Creates a new instance of FileAssert.
static AbstractInputStreamAssert<?,? extends InputStream>	then(InputStream actual)	Creates a new instance of InputStreamAssert.
static AbstractBooleanAssert<?>	then(Boolean actual)	Creates a new instance of BooleanAssert.
static AbstractByteAssert<?>	then(Byte actual)	Creates a new instance of ByteAssert.
static AbstractCharacterAssert<?>	then(Character actual)	Creates a new instance of CharacterAssert.
static AbstractCharSequenceAssert<?,? extends CharSequence>	then(CharSequence actual)	Creates a new instance of CharSequenceAssert.
static AbstractClassAssert<?>	then(Class<?> actual)	Creates a new instance of ClassAssert
static AbstractDoubleAssert<?>	then(Double actual)	Creates a new instance of DoubleAssert.
static AbstractFloatAssert<?>	then(Float actual)	Creates a new instance of FloatAssert.
static AbstractIntegerAssert<?>	then(Integer actual)	Creates a new instance of IntegerAssert.
static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	then(Iterable<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)	Creates a new instance of FactoryBasedNavigableIterableAssert allowing to navigate to any Iterable element in order to perform assertions on it.
static <T> IterableAssert<T>	then(Iterable<? extends T> actual)	Creates a new instance of IterableAssert.
static AbstractLongAssert<?>	then(Long actual)	Creates a new instance of LongAssert.
static AbstractShortAssert<?>	then(Short actual)	Creates a new instance of ShortAssert.
static AbstractCharSequenceAssert<?,String>	then(String actual)	Creates a new instance of StringAssert.
static AbstractThrowableAssert<?,? extends Throwable>	then(Throwable actual)	Creates a new instance of ThrowableAssert.
static AbstractBigDecimalAssert<?>	then(BigDecimal actual)	Creates a new instance of BigDecimalAssert.
static AbstractBigIntegerAssert<?>	then(BigInteger actual)	Creates a new instance of BigIntegerAssert.
static AbstractUriAssert<?>	then(URI actual)	Creates a new instance of UriAssert.
static AbstractUrlAssert<?>	then(URL actual)	Creates a new instance of UrlAssert.
static AbstractPathAssert<?>	then(Path actual)	Creates a new instance of PathAssert
static AbstractInstantAssert<?>	then(Instant actual)	Creates a new instance of InstantAssert.
static AbstractLocalDateAssert<?>	then(LocalDate actual)	Creates a new instance of LocalDateAssert.
static AbstractLocalDateTimeAssert<?>	then(LocalDateTime actual)	Creates a new instance of LocalDateTimeAssert.
static AbstractLocalTimeAssert<?>	then(LocalTime actual)	Creates a new instance of LocalTimeAssert.
static AbstractOffsetDateTimeAssert<?>	then(OffsetDateTime actual)	Creates a new instance of OffsetTimeAssert.
static AbstractOffsetTimeAssert<?>	then(OffsetTime actual)	Creates a new instance of OffsetTimeAssert.
static AbstractZonedDateTimeAssert<?>	then(ZonedDateTime actual)	Creates a new instance of ZonedDateTimeAssert.
static AtomicBooleanAssert	then(AtomicBoolean actual)	Create assertion for AtomicBoolean.
static AtomicIntegerAssert	then(AtomicInteger actual)	Create assertion for AtomicInteger.
static AtomicIntegerArrayAssert	then(AtomicIntegerArray actual)	Create assertion for AtomicIntegerArray.
static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT>	then(AtomicIntegerFieldUpdater<OBJECT> actual)	Create assertion for AtomicIntegerFieldUpdater.
static AtomicLongAssert	then(AtomicLong actual)	Create assertion for AtomicLong.
static AtomicLongArrayAssert	then(AtomicLongArray actual)	Create assertion for AtomicLongArray.
static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT>	then(AtomicLongFieldUpdater<OBJECT> actual)	Create assertion for AtomicLongFieldUpdater.
static <VALUE> AtomicMarkableReferenceAssert<VALUE>	then(AtomicMarkableReference<VALUE> actual)	Create assertion for AtomicMarkableReference.
static <VALUE> AtomicReferenceAssert<VALUE>	then(AtomicReference<VALUE> actual)	Create assertion for AtomicReference.
static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT>	then(AtomicReferenceArray<ELEMENT> actual)	Create assertion for AtomicReferenceArray.
static <FIELD,OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT>	then(AtomicReferenceFieldUpdater<OBJECT,FIELD> actual)	Create assertion for AtomicReferenceFieldUpdater.
static <VALUE> AtomicStampedReferenceAssert<VALUE>	then(AtomicStampedReference<VALUE> actual)	Create assertion for AtomicStampedReference.
static <RESULT> CompletableFutureAssert<RESULT>	then(CompletableFuture<RESULT> future)	Create assertion for CompletableFuture.
static <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT>	then(Future<RESULT> actual)	Creates a new instance of FutureAssert
static AbstractDateAssert<?>	then(Date actual)	Creates a new instance of DateAssert.
static DoublePredicateAssert	then(DoublePredicate actual)	Create assertion for DoublePredicate.
static IntPredicateAssert	then(IntPredicate actual)	Create assertion for IntPredicate.
static LongPredicateAssert	then(LongPredicate actual)	Create assertion for LongPredicate.
static <T> PredicateAssert<T>	then(Predicate<T> actual)	Create assertion for Predicate.
static <T> IterableAssert<T>	then(Iterator<? extends T> actual)	Creates a new instance of IterableAssert.
static <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	then(List<? extends ELEMENT> actual, Class<ELEMENT_ASSERT> assertClass)	Creates a new instance of ClassBasedNavigableListAssert tallowing to navigate to any List element in order to perform assertions on it.
static <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT>	then(List<? extends ELEMENT> actual, AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)	Creates a new instance of FactoryBasedNavigableListAssert allowing to navigate to any List element in order to perform assertions on it.
static <T> ListAssert<T>	then(List<? extends T> actual)	Creates a new instance of ListAssert.
static <K,V> MapAssert<K,V>	then(Map<K,V> actual)	Creates a new instance of MapAssert.
static <VALUE> OptionalAssert<VALUE>	then(Optional<VALUE> optional)	Create assertion for Optional.
static OptionalDoubleAssert	then(OptionalDouble optional)	Create assertion for OptionalDouble.
static OptionalIntAssert	then(OptionalInt optional)	Create assertion for OptionalInt.
static OptionalLongAssert	then(OptionalLong optional)	Create assertion for OptionalLong.
static <ELEMENT,STREAM extends BaseStream<ELEMENT,STREAM>> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>	then(BaseStream<? extends ELEMENT,STREAM> actual)	Creates a new instance of ListAssert from the given BaseStream.
static <T> T	then(AssertProvider<T> component)	Delegates the creation of the Assert to the AssertProvider.assertThat() of the given component.
static <T extends Comparable<? super T>> AbstractComparableAssert<?,T>	then(T actual)	Creates a new instance of GenericComparableAssert with standard comparison semantics.
static <T> AbstractObjectArrayAssert<?,T>	then(T[] actual)	Creates a new instance of ObjectArrayAssert.
static AbstractThrowableAssert<?,? extends Throwable>	thenCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.
static AbstractThrowableAssert<?,? extends Throwable>	thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)	Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.

Methods inherited from class org.assertj.core.api.Assertions

allOf, allOf, anyOf, anyOf, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThatCode, assertThatExceptionOfType, assertThatIllegalArgumentException, assertThatIllegalStateException, assertThatIOException, assertThatNullPointerException, assertThatThrownBy, atIndex, byLessThan, byLessThan, byLessThan, byLessThan, byLessThan, byLessThan, byLessThan, byLessThan, byLessThan, catchThrowable, contentOf, contentOf, contentOf, contentOf, contentOf, contentOf, doesNotHave, entry, extractProperty, extractProperty, fail, fail, fail, failBecauseExceptionWasNotThrown, filter, filter, from, in, linesOf, linesOf, linesOf, linesOf, linesOf, linesOf, not, not, notIn, offset, offset, registerCustomDateFormat, registerCustomDateFormat, registerFormatterForType, setAllowComparingPrivateFields, setAllowExtractingPrivateFields, setLenientDateParsing, setMaxElementsForPrinting, setMaxLengthForSingleLineDescription, setRemoveAssertJRelatedElementsFromStackTrace, shouldHaveThrown, tuple, useDefaultDateFormatsOnly, useDefaultRepresentation, useRepresentation, within, within, within, within, within, within, within, within, within, withinPercentage, withinPercentage, withinPercentage, withPrecision, withPrecision

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BDDAssertions

protected BDDAssertions()

Creates a new BDDAssertions.

Method Detail

then

public static <T> PredicateAssert<T> then(Predicate<T> actual)

Create assertion for Predicate.

Type Parameters:

T - the type of the value contained in the Predicate.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

Since:

3.5.0

then

public static IntPredicateAssert then(IntPredicate actual)

Create assertion for IntPredicate.

Returns:

the created assertion object.

Since:

3.5.0

then

public static LongPredicateAssert then(LongPredicate actual)

Create assertion for LongPredicate.

Returns:

the created assertion object.

Since:

3.5.0

then

public static DoublePredicateAssert then(DoublePredicate actual)

Create assertion for DoublePredicate.

Returns:

the created assertion object.

Since:

3.5.0

then

public static <VALUE> OptionalAssert<VALUE> then(Optional<VALUE> optional)

Create assertion for Optional.

Type Parameters:

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

Parameters:

optional - the actual value.

Returns:

the created assertion object.

then

public static OptionalIntAssert then(OptionalInt optional)

Create assertion for OptionalInt.

Parameters:

optional - the actual value.

Returns:

the created assertion object.

then

public static OptionalLongAssert then(OptionalLong optional)

Create assertion for OptionalLong.

Parameters:

optional - the actual value.

Returns:

the created assertion object.

then

public static OptionalDoubleAssert then(OptionalDouble optional)

Create assertion for OptionalDouble.

Parameters:

optional - the actual value.

Returns:

the created assertion object.

then

public static AbstractBigDecimalAssert<?> then(BigDecimal actual)

Creates a new instance of BigDecimalAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractBigIntegerAssert<?> then(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

then

public static AbstractBooleanAssert<?> then(boolean actual)

Creates a new instance of BooleanAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractBooleanAssert<?> then(Boolean actual)

Creates a new instance of BooleanAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractBooleanArrayAssert<?> then(boolean[] actual)

Creates a new instance of BooleanArrayAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractByteAssert<?> then(byte actual)

Creates a new instance of ByteAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractByteAssert<?> then(Byte actual)

Creates a new instance of ByteAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractByteArrayAssert<?> then(byte[] actual)

Creates a new instance of ByteArrayAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractCharacterAssert<?> then(char actual)

Creates a new instance of CharacterAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractCharArrayAssert<?> then(char[] actual)

Creates a new instance of CharArrayAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractCharacterAssert<?> then(Character actual)

Creates a new instance of CharacterAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractClassAssert<?> then(Class<?> actual)

Creates a new instance of ClassAssert

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static <T extends Comparable<? super T>> AbstractComparableAssert<?,T> then(T actual)

Creates a new instance of GenericComparableAssert with standard comparison semantics.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static <T> IterableAssert<T> then(Iterable<? extends T> actual)

Creates a new instance of IterableAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static <T> IterableAssert<T> then(Iterator<? extends T> actual)

Creates a new instance of IterableAssert. The Iterator is first converted into an Iterable

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> then(Iterable<? extends ELEMENT> actual,
                                                                                                                                                                                                                                               AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)

Creates a new instance of FactoryBasedNavigableIterableAssert allowing to navigate to any Iterable element in order to perform assertions on it.

Navigational methods provided:

• first()
• last()
• element(index)

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()
 then(hobbits, stringAssertFactory).first()
                                   .startsWith("fro")
                                   .endsWith("do");

Parameters:

actual - the actual value.

assertFactory - the factory used to create the elements assert instance.

Returns:

the created assertion object.

then

public static <ACTUAL extends Iterable<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> then(ACTUAL actual,
                                                                                                                                                                                                                                             Class<ELEMENT_ASSERT> assertClass)

Creates a new instance of ClassBasedNavigableIterableAssert allowing to navigate to any Iterable element in order to perform assertions on it.

Navigational methods provided:

• first()
• last()
• element(index)

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()
 then(hobbits, StringAssert.class).first()
                                  .startsWith("fro")
                                  .endsWith("do");

Parameters:

actual - the actual value.

assertClass - the class used to create the elements assert instance.

Returns:

the created assertion object.

then

public static <ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> FactoryBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> then(List<? extends ELEMENT> actual,
                                                                                                                                                                                                                                       AssertFactory<ELEMENT,ELEMENT_ASSERT> assertFactory)

Creates a new instance of FactoryBasedNavigableListAssert allowing to navigate to any List element in order to perform assertions on it.

Navigational methods provided:

• first()
• last()
• element(index)

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()
 then(hobbits, stringAssertFactory).first()
                                   .startsWith("fro")
                                   .endsWith("do");

Parameters:

actual - the actual value.

assertFactory - the factory used to create the elements assert instance.

Returns:

the created assertion object.

then

public static <ELEMENT,ACTUAL extends List<? extends ELEMENT>,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>> ClassBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> then(List<? extends ELEMENT> actual,
                                                                                                                                                                                                                                     Class<ELEMENT_ASSERT> assertClass)

Creates a new instance of ClassBasedNavigableListAssert tallowing to navigate to any List element in order to perform assertions on it.

Navigational methods provided:

• first()
• last()
• element(index)

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()
 then(hobbits, StringAssert.class).first()
                                  .startsWith("fro")
                                  .endsWith("do");

Parameters:

actual - the actual value.

assertClass - the class used to create the elements assert instance.

Returns:

the created assertion object.

then

public static AbstractDoubleAssert<?> then(double actual)

Creates a new instance of DoubleAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractDoubleAssert<?> then(Double actual)

Creates a new instance of DoubleAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractDoubleArrayAssert<?> then(double[] actual)

Creates a new instance of DoubleArrayAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractFileAssert<?> then(File actual)

Creates a new instance of FileAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractPathAssert<?> then(Path actual)

Creates a new instance of PathAssert

Parameters:

actual - the path to test

Returns:

the created assertion object

then

public static <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT> then(Future<RESULT> actual)

Creates a new instance of FutureAssert

Parameters:

actual - the future to test

Returns:

the created assertion object

Since:

2.7.0 / 3.7.0

then

public static AbstractInputStreamAssert<?,? extends InputStream> then(InputStream actual)

Creates a new instance of InputStreamAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractFloatAssert<?> then(float actual)

Creates a new instance of FloatAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractFloatAssert<?> then(Float actual)

Creates a new instance of FloatAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractFloatArrayAssert<?> then(float[] actual)

Creates a new instance of FloatArrayAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractIntegerAssert<?> then(int actual)

Creates a new instance of IntegerAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractIntArrayAssert<?> then(int[] actual)

Creates a new instance of IntArrayAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractIntegerAssert<?> then(Integer actual)

Creates a new instance of IntegerAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static <T> ListAssert<T> then(List<? extends T> actual)

Creates a new instance of ListAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractLongAssert<?> then(long actual)

Creates a new instance of LongAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractLongAssert<?> then(Long actual)

Creates a new instance of LongAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractLongArrayAssert<?> then(long[] actual)

Creates a new instance of LongArrayAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static <T> AbstractObjectAssert<?,T> then(T actual)

Creates a new instance of ObjectAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static <T> AbstractObjectArrayAssert<?,T> then(T[] actual)

Creates a new instance of ObjectArrayAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static <K,V> MapAssert<K,V> then(Map<K,V> actual)

Creates a new instance of MapAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractShortAssert<?> then(short actual)

Creates a new instance of ShortAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractShortAssert<?> then(Short actual)

Creates a new instance of ShortAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractShortArrayAssert<?> then(short[] actual)

Creates a new instance of ShortArrayAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractCharSequenceAssert<?,? extends CharSequence> then(CharSequence actual)

Creates a new instance of CharSequenceAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractCharSequenceAssert<?,String> then(String actual)

Creates a new instance of StringAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractDateAssert<?> then(Date actual)

Creates a new instance of DateAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AtomicBooleanAssert then(AtomicBoolean actual)

Create assertion for AtomicBoolean.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

Since:

2.7.0 / 3.7.0

then

public static AtomicIntegerAssert then(AtomicInteger actual)

Create assertion for AtomicInteger.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

Since:

2.7.0 / 3.7.0

then

public static AtomicIntegerArrayAssert then(AtomicIntegerArray actual)

Create assertion for AtomicIntegerArray.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

Since:

2.7.0 / 3.7.0

then

public static <OBJECT> AtomicIntegerFieldUpdaterAssert<OBJECT> then(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.

Since:

2.7.0 / 3.7.0

then

public static AtomicLongAssert then(AtomicLong actual)

Create assertion for AtomicLong.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

Since:

2.7.0 / 3.7.0

then

public static AtomicLongArrayAssert then(AtomicLongArray actual)

Create assertion for AtomicLongArray.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

Since:

2.7.0 / 3.7.0

then

public static <OBJECT> AtomicLongFieldUpdaterAssert<OBJECT> then(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.

Since:

2.7.0 / 3.7.0

then

public static <VALUE> AtomicReferenceAssert<VALUE> then(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.

Since:

2.7.0 / 3.7.0

then

public static <ELEMENT> AtomicReferenceArrayAssert<ELEMENT> then(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.

Since:

2.7.0 / 3.7.0

then

public static <FIELD,OBJECT> AtomicReferenceFieldUpdaterAssert<FIELD,OBJECT> then(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.

Since:

2.7.0 / 3.7.0

then

public static <VALUE> AtomicMarkableReferenceAssert<VALUE> then(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.

Since:

2.7.0 / 3.7.0

then

public static <VALUE> AtomicStampedReferenceAssert<VALUE> then(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.

Since:

2.7.0 / 3.7.0

then

public static AbstractThrowableAssert<?,? extends Throwable> then(Throwable actual)

Creates a new instance of ThrowableAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion Throwable.

thenThrownBy

public static AbstractThrowableAssert<?,? extends Throwable> thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)

Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.

Java 8 example :

 @Test
  public void testException() {
    thenThrownBy(() -> { throw new Exception("boom!"); }).isInstanceOf(Exception.class)
                                                         .hasMessageContaining("boom");
  }

Parameters:

shouldRaiseThrowable - 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.

thenCode

public static AbstractThrowableAssert<?,? extends Throwable> thenCode(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
 thenCode(callable).isInstanceOf(Exception.class)
                   .hasMessageContaining("boom");
                                                      
 // assertion fails
 thenCode(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 Assertions.catchThrowable(ThrowableAssert.ThrowingCallable) as shown below.

 ThrowingCallable doNothing = () -> {
   // do nothing 
 }; 
 
 // assertion fails and "display me" appears in the assertion error
 thenCode(doNothing).as("display me")
                    .isInstanceOf(Exception.class);

 // assertion will fail AND "display me" will appear in the error
 Throwable thrown = catchThrowable(doNothing);
 thenCode(thrown).as("display me")
                 .isInstanceOf(Exception.class); 

This method was not named then 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

then

public static AbstractLocalDateAssert<?> then(LocalDate actual)

Creates a new instance of LocalDateAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractLocalDateTimeAssert<?> then(LocalDateTime actual)

Creates a new instance of LocalDateTimeAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractZonedDateTimeAssert<?> then(ZonedDateTime actual)

Creates a new instance of ZonedDateTimeAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractLocalTimeAssert<?> then(LocalTime actual)

Creates a new instance of LocalTimeAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractOffsetTimeAssert<?> then(OffsetTime actual)

Creates a new instance of OffsetTimeAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractInstantAssert<?> then(Instant actual)

Creates a new instance of InstantAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

Since:

3.7.0

then

public static AbstractUriAssert<?> then(URI actual)

Creates a new instance of UriAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractUrlAssert<?> then(URL actual)

Creates a new instance of UrlAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static AbstractOffsetDateTimeAssert<?> then(OffsetDateTime actual)

Creates a new instance of OffsetTimeAssert.

Parameters:

actual - the actual value.

Returns:

the created assertion object.

then

public static <RESULT> CompletableFutureAssert<RESULT> then(CompletableFuture<RESULT> future)

Create assertion for CompletableFuture.

Type Parameters:

RESULT - the type of the value contained in the CompletableFuture.

Parameters:

future - the actual value.

Returns:

the created assertion object.

then

public static <T extends AssertDelegateTarget> T then(T assertion)

Returns the given assertion. This method improves code readability by surrounding the given assertion with then.

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.then
     then(button.isBlinking()).isTrue();
   }

   void isNotBlinking() {
     // standard assertion from core Assertions.then
     then(button.isBlinking()).isFalse();
   }
 }

As MyButtonAssert implements AssertDelegateTarget, you can use then(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 then
   then(buttonAssert).isNotBlinking(); // same as : buttonAssert.isNotBlinking();

   button.setBlinking(true);

   then(buttonAssert).isBlinking(); // same as : buttonAssert.isBlinking();
 }

Type Parameters:

T - the generic type of the user-defined assert.

Parameters:

assertion - the assertion to return.

Returns:

the given assertion.

then

public static <T> T then(AssertProvider<T> component)

Delegates the creation of the Assert to the AssertProvider.assertThat() of the given component.

Read the comments on AssertProvider for an example of its usage.

Parameters:

component - the component that creates its own assert

Returns:

the associated Assert of the given component

then

public static <ELEMENT,STREAM extends BaseStream<ELEMENT,STREAM>> AbstractListAssert<?,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>> then(BaseStream<? extends ELEMENT,STREAM> actual)

Creates a new instance of ListAssert from the given BaseStream.

Be aware that to create the returned ListAssert the given the BaseStream is consumed so it won't be possible to use it again. Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the BaseStream.

This method accepts Stream and primitive stream variants IntStream, LongStream and DoubleStream.

Parameters:

actual - the actual BaseStream value.

Returns:

the created assertion object.