java.lang.Object
- org.assertj.core.api.Assertions
- - org.assertj.core.api.BDDAssertions

All Implemented Interfaces:

InstanceOfAssertFactories
```
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);
 }
```
Use and to avoid clash with other libraries (like BDDMockito) exposing 'then(object)'. You might have to ignore a warning like: The static method BDDAssertions.then() should be accessed in a static way.
Author:

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

Field Summary

Fields
Modifier and Type Field Description

static BDDAssertions and
A BDDAssertions which allows to blend assertions with other libraries when the name 'then' cause clash.
- Fields inherited from interface org.assertj.core.api.InstanceOfAssertFactories
  ARRAY, ATOMIC_BOOLEAN, ATOMIC_INTEGER, ATOMIC_INTEGER_ARRAY, ATOMIC_INTEGER_FIELD_UPDATER, ATOMIC_LONG, ATOMIC_LONG_ARRAY, ATOMIC_LONG_FIELD_UPDATER, ATOMIC_MARKABLE_REFERENCE, ATOMIC_REFERENCE, ATOMIC_REFERENCE_ARRAY, ATOMIC_REFERENCE_FIELD_UPDATER, ATOMIC_STAMPED_REFERENCE, BIG_DECIMAL, BIG_INTEGER, BOOLEAN, BOOLEAN_ARRAY, BYTE, BYTE_ARRAY, CHAR_ARRAY, CHAR_SEQUENCE, CHARACTER, CLASS, COMPLETABLE_FUTURE, COMPLETION_STAGE, DATE, DOUBLE, DOUBLE_ARRAY, DOUBLE_PREDICATE, DOUBLE_STREAM, FILE, FLOAT, FLOAT_ARRAY, FUTURE, INPUT_STREAM, INSTANT, INT_ARRAY, INT_PREDICATE, INT_STREAM, INTEGER, ITERABLE, ITERATOR, LIST, LOCAL_DATE, LOCAL_DATE_TIME, LOCAL_TIME, LONG, LONG_ARRAY, LONG_PREDICATE, LONG_STREAM, MAP, OFFSET_DATE_TIME, OFFSET_TIME, OPTIONAL, OPTIONAL_DOUBLE, OPTIONAL_INT, OPTIONAL_LONG, PATH, PREDICATE, SHORT, SHORT_ARRAY, SPLITERATOR, STREAM, STRING, STRING_BUFFER, STRING_BUILDER, THROWABLE, URI_TYPE, URL_TYPE, ZONED_DATE_TIME

Constructor Summary

Constructors
Modifier Constructor Description

protected BDDAssertions()
Creates a new BDDAssertions.

Method Summary

All Methods Static Methods Concrete Methods
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 ClassAssert`	`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 AbstractStringAssert<?>`	`then(String actual)`	Creates a new instance of `StringAssert`.
`static AbstractCharSequenceAssert<?,? extends CharSequence>`	`then(StringBuffer actual)`	Creates a new instance of `CharSequenceAssert` from a `StringBuffer`.
`static AbstractCharSequenceAssert<?,? extends CharSequence>`	`then(StringBuilder actual)`	Creates a new instance of `CharSequenceAssert` from a `StringBuilder`.
`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> CompletableFutureAssert<RESULT>`	`then(CompletionStage<RESULT> actual)`	Create assertion for `CompletionStage` by converting it to a `CompletableFuture` and returning a `CompletableFutureAssert`.
`static <RESULT> FutureAssert<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> IteratorAssert<T>`	`then(Iterator<? extends T> actual)`	Creates a new instance of `IteratorAssert`.
`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` allowing 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> SpliteratorAssert<ELEMENT>`	`then(Spliterator<ELEMENT> actual)`	Creates a new instance of `SpliteratorAssert` from the given `Spliterator`.
`static ListAssert<Double>`	`then(DoubleStream actual)`	Creates a new instance of `ListAssert` from the given `DoubleStream`.
`static ListAssert<Integer>`	`then(IntStream actual)`	Creates a new instance of `ListAssert` from the given `IntStream`.
`static ListAssert<Long>`	`then(LongStream actual)`	Creates a new instance of `ListAssert` from the given `LongStream`.
`static <ELEMENT> ListAssert<ELEMENT>`	`then(Stream<? extends ELEMENT> actual)`	Creates a new instance of `ListAssert` from the given `Stream`.
`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> ObjectArrayAssert<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 <T> ObjectAssert<T>`	`thenObject(T actual)`	Creates a new instance of `ObjectAssert` for any object.
`static AbstractThrowableAssert<?,? extends Throwable>`	`thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)`	Allows to capture and then assert on a `Throwable` (easier done with lambdas).
`static AbstractThrowableAssert<?,? extends Throwable>`	`thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, String description, Object... args)`	Allows to capture and then assert on a `Throwable` like `thenThrownBy(ThrowingCallable)` but this method let you set the assertion description the same way you do with `as(String, Object...)`.

Methods inherited from class org.assertj.core.api.Assertions
allOf, allOf, anyOf, anyOf, as, 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, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThat, assertThatCode, assertThatExceptionOfType, assertThatIllegalArgumentException, assertThatIllegalStateException, assertThatIOException, assertThatNullPointerException, assertThatObject, assertThatThrownBy, assertThatThrownBy, atIndex, byLessThan, byLessThan, byLessThan, byLessThan, byLessThan, byLessThan, byLessThan, byLessThan, byLessThan, catchThrowable, catchThrowableOfType, 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, setExtractBareNamePropertyMethods, 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

- Field Detail
  - and
```
public static final BDDAssertions and
```
    A BDDAssertions which allows to blend assertions with other libraries when the name 'then' cause clash.
    Examples:
    import static org.assertj.core.api.BDDAssertions.and; import static org.mockito.BDDMockito.then; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.times; // suppress and.then warning: The static method BDDAssertions.then() should be accessed in a static way @SuppressWarnings("static-access") @Test public void bdd_assertions_with_bdd_mockito() { // GIVEN Person person = mock(Person.class) // WHEN person.ride(bike); person.ride(bike); // THEN // mockito then() then(person).should(times(2)).ride(bike); // use AssertJ and.then(person) as then(person) would clash with mockito then(person) and.then(person.hasBike()).isTrue(); }
    
    Can also be used to add extra readability:
    import static org.assertj.core.api.BDDAssertions.and; import static org.assertj.core.api.BDDAssertions.then; // suppress and.then warning: The static method BDDAssertions.then() should be accessed in a static way @SuppressWarnings("static-access") @Test public void bdd_assertions_with_and_field() { // ... then(person.hasBike()).isTrue() and.then(bike.isNew()).isFalse(); }
    Since:
    
    3.14.0
- 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.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assertion object.
    
    Since:
    
    3.5.0
  - then
```
public static LongPredicateAssert then(LongPredicate actual)
```
    Create assertion for LongPredicate.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assertion object.
    
    Since:
    
    3.5.0
  - then
```
public static DoublePredicateAssert then(DoublePredicate actual)
```
    Create assertion for DoublePredicate.
    
    Parameters:
    
    actual - the actual value.
    
    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 ClassAssert 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.
    
    Type Parameters:
    
    T - the actual type
    
    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.
    
    Type Parameters:
    
    T - the actual elements type
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assertion object.
  - then
```
public static <T> IteratorAssert<T> then(Iterator<? extends T> actual)
```
    Creates a new instance of IteratorAssert.
    Breaking change in version 3.12.0: this method does not return anymore an IterableAssert but an IteratorAssert.
    In order to access assertions from IterableAssert, use AbstractIteratorAssert.toIterable().
    IteratorAssert instances have limited assertions because it does not consume iterator's elements.
    Examples:
    Iterator<String> bestBasketBallPlayers = getBestBasketBallPlayers(); then(bestBasketBallPlayers).hasNext() // Iterator assertion .toIterable() // switch to Iterable assertions .contains("Jordan", "Magic", "Lebron"); // Iterable assertion
    Type Parameters:
    
    T - the actual elements type
    
    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");
    Type Parameters:
    
    ACTUAL - The actual type
    
    ELEMENT - The actual elements type
    
    ELEMENT_ASSERT - The actual elements AbstractAssert type
    
    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");
    Type Parameters:
    
    ACTUAL - The actual type
    
    ELEMENT - The actual elements type
    
    ELEMENT_ASSERT - The actual elements AbstractAssert type
    
    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");
    Type Parameters:
    
    ACTUAL - The actual type
    
    ELEMENT - The actual elements type
    
    ELEMENT_ASSERT - The actual elements AbstractAssert type
    
    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 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 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");
    Type Parameters:
    
    ACTUAL - The actual type
    
    ELEMENT - The actual elements type
    
    ELEMENT_ASSERT - The actual elements AbstractAssert type
    
    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> FutureAssert<RESULT> then(Future<RESULT> actual)
```
    Creates a new instance of FutureAssert
    
    Type Parameters:
    
    RESULT - the type of the value contained in the Future.
    
    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.
    
    Type Parameters:
    
    T - the type of elements.
    
    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> ObjectAssert<T> then(T actual)
```
    Creates a new instance of ObjectAssert.
    
    Type Parameters:
    
    T - the type of the actual value.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assertion object.
  - then
```
public static <T> ObjectArrayAssert<T> then(T[] actual)
```
    Creates a new instance of ObjectArrayAssert.
    
    Type Parameters:
    
    T - the actual's elements type.
    
    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.
    
    Type Parameters:
    
    K - the type of keys in the map.
    
    V - the type of values in the map.
    
    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<?,? extends CharSequence> then(StringBuilder actual)
```
    Creates a new instance of CharSequenceAssert from a StringBuilder.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assertion object.
    
    Since:
    
    3.11.0
  - then
```
public static AbstractCharSequenceAssert<?,? extends CharSequence> then(StringBuffer actual)
```
    Creates a new instance of CharSequenceAssert from a StringBuffer.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assertion object.
    
    Since:
    
    3.11.0
  - then
```
public static AbstractStringAssert<?> 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 (easier done with lambdas).
    Example :
    @Test public void testException() { thenThrownBy(() -> { throw new Exception("boom!") }).isInstanceOf(Exception.class) .hasMessageContaining("boom"); }
    If the provided ThrowableAssert.ThrowingCallable does not raise an exception, an error is immediately thrown, in that case the test description provided with as(String, Object...) is not honored.
    To use a test description, use Assertions.catchThrowable(ThrowableAssert.ThrowingCallable) as shown below:
    // assertion will fail but "display me" won't appear in the error thenThrownBy(() -> {}).as("display me") .isInstanceOf(Exception.class); // assertion will fail AND "display me" will appear in the error Throwable thrown = catchThrowable(() -> {}); assertThat(thrown).as("display me") .isInstanceOf(Exception.class);
    Alternatively you can also use assertThatCode(ThrowingCallable) for the test description provided with as(String, Object...) to always be honored.
    Parameters:
    
    shouldRaiseThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.
    
    Returns:
    
    the created ThrowableAssert.
  - thenThrownBy
```
public static AbstractThrowableAssert<?,? extends Throwable> thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable,
                                                                                String description,
                                                                                Object... args)
```
    Allows to capture and then assert on a Throwable like thenThrownBy(ThrowingCallable) but this method let you set the assertion description the same way you do with as(String, Object...).
    Example:
    @Test public void testException() { // if this assertion failed (but it doesn't), the error message would start with [Test explosive code] thenThrownBy(() -> { throw new IOException("boom!") }, "Test explosive code") .isInstanceOf(IOException.class) .hasMessageContaining("boom"); }
    If the provided ThrowingCallable does not raise an exception, an error is immediately thrown.
    The test description provided is honored but not the one with as(String, Object...), example:
    // assertion will fail but "display me" won't appear in the error message thenThrownBy(() -> {}).as("display me") .isInstanceOf(Exception.class); // assertion will fail AND "display me" will appear in the error message thenThrownBy(() -> {}, "display me").isInstanceOf(Exception.class);
    Parameters:
    
    shouldRaiseThrowable - The ThrowableAssert.ThrowingCallable or lambda with the code that should raise the throwable.
    
    description - the new description to set.
    
    args - optional parameter if description is a format String.
    
    Returns:
    
    the created ThrowableAssert.
    
    Since:
    
    3.9.0
  - 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
  - thenObject
```
public static <T> ObjectAssert<T> thenObject(T actual)
```
    Creates a new instance of ObjectAssert for any object.
    This overload is useful, when an overloaded method of then(...) takes precedence over the generic then(Object).
    Example:
    Cast necessary because then(List) "forgets" actual type:
    then(new LinkedList<>(asList("abc"))).matches(list -> ((Deque<String>) list).getFirst().equals("abc"));
    No cast needed, but also no additional list assertions:
    thenObject(new LinkedList<>(asList("abc"))).matches(list -> list.getFirst().equals("abc"));
    Type Parameters:
    
    T - the type of the actual value.
    
    Parameters:
    
    actual - the actual value.
    
    Returns:
    
    the created assertion object.
    
    Since:
    
    3.12.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 <RESULT> CompletableFutureAssert<RESULT> then(CompletionStage<RESULT> actual)
```
    Create assertion for CompletionStage by converting it to a CompletableFuture and returning a CompletableFutureAssert.
    If the given CompletionStage is null, the CompletableFuture in the returned CompletableFutureAssert will also be null.
    
    Type Parameters:
    
    RESULT - the type of the value contained in the CompletionStage.
    
    Parameters:
    
    actual - 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.
    
    Type Parameters:
    
    T - the AssertProvider wrapped type.
    
    Parameters:
    
    component - the component that creates its own assert
    
    Returns:
    
    the associated Assert of the given component
  - then
```
public static <ELEMENT> ListAssert<ELEMENT> then(Stream<? extends ELEMENT> actual)
```
    Creates a new instance of ListAssert from the given Stream.
    Be aware that the Stream under test will be converted to a List when an assertions require to inspect its content. Once this is done the Stream can't reused as it would have been consumed.
    Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the Stream.
    Examples:
    // you can chain multiple assertions on the Stream as it is converted to a List then(Stream.of(1, 2, 3)).contains(1) .doesNotContain(42);
    
    The following assertion fails as the Stream under test is converted to a List before being compared to the expected Stream:
    // FAIL: the Stream under test is converted to a List and compared to a Stream but a List is not a Stream. then(Stream.of(1, 2, 3)).isEqualTo(Stream.of(1, 2, 3));
    
    These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the Stream to a List.
    // The following assertions succeed as it only performs reference checking which does not require to convert the Stream to a List Stream<Integer> stream = Stream.of(1, 2, 3); then(stream).isEqualTo(stream) .isSameAs(stream);
    Type Parameters:
    
    ELEMENT - the type of elements.
    
    Parameters:
    
    actual - the actual Stream value.
    
    Returns:
    
    the created assertion object.
  - then
```
public static ListAssert<Double> then(DoubleStream actual)
```
    Creates a new instance of ListAssert from the given DoubleStream.
    Be aware that the DoubleStream under test will be converted to a List when an assertions require to inspect its content. Once this is done the DoubleStream can't reused as it would have been consumed.
    Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the DoubleStream.
    Examples:
    // you can chain multiple assertions on the DoubleStream as it is converted to a List then(DoubleStream.of(1.0, 2.0, 3.0)).contains(1.0) .doesNotContain(42.0);
    
    The following assertion fails as the DoubleStream under test is converted to a List before being compared to the expected DoubleStream:
    // FAIL: the DoubleStream under test is converted to a List and compared to a DoubleStream but a List is not a DoubleStream. then(DoubleStream.of(1.0, 2.0, 3.0)).isEqualTo(DoubleStream.of(1.0, 2.0, 3.0));
    
    These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the DoubleStream to a List.
    // The following assertions succeed as it only performs reference checking which does not require to convert the DoubleStream to a List DoubleStream stream = DoubleStream.of(1.0, 2.0, 3.0); then(stream).isEqualTo(stream) .isSameAs(stream);
    Parameters:
    
    actual - the actual DoubleStream value.
    
    Returns:
    
    the created assertion object.
  - then
```
public static ListAssert<Long> then(LongStream actual)
```
    Creates a new instance of ListAssert from the given LongStream.
    Be aware that the LongStream under test will be converted to a List when an assertions require to inspect its content. Once this is done the LongStream can't reused as it would have been consumed.
    Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the LongStream.
    Examples:
    // you can chain multiple assertions on the LongStream as it is converted to a List then(LongStream.of(1, 2, 3)).contains(1) .doesNotContain(42);
    
    The following assertion fails as the LongStream under test is converted to a List before being compared to the expected LongStream:
    // FAIL: the LongStream under test is converted to a List and compared to a LongStream but a List is not a LongStream. then(LongStream.of(1, 2, 3)).isEqualTo(LongStream.of(1, 2, 3));
    
    These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the LongStream to a List.
    // The following assertions succeed as it only performs reference checking which does not require to convert the LongStream to a List LongStream stream = LongStream.of(1, 2, 3); then(stream).isEqualTo(stream) .isSameAs(stream);
    Parameters:
    
    actual - the actual LongStream value.
    
    Returns:
    
    the created assertion object.
  - then
```
public static ListAssert<Integer> then(IntStream actual)
```
    Creates a new instance of ListAssert from the given IntStream.
    Be aware that the IntStream under test will be converted to a List when an assertions require to inspect its content. Once this is done the IntStream can't reused as it would have been consumed.
    Calling multiple methods on the returned ListAssert is safe as it only interacts with the List built from the IntStream.
    Examples:
    // you can chain multiple assertions on the IntStream as it is converted to a List then(IntStream.of(1, 2, 3)).contains(1) .doesNotContain(42);
    
    The following assertion fails as the IntStream under test is converted to a List before being compared to the expected IntStream:
    // FAIL: the IntStream under test is converted to a List and compared to a IntStream but a List is not a IntStream. then(IntStream.of(1, 2, 3)).isEqualTo(IntStream.of(1, 2, 3));
    
    These assertions succeed as isEqualTo and isSameAs checks references which does not require to convert the IntStream to a List.
    // The following assertions succeed as it only performs reference checking which does not require to convert the IntStream to a List IntStream stream = IntStream.of(1, 2, 3); then(stream).isEqualTo(stream) .isSameAs(stream);
    Parameters:
    
    actual - the actual IntStream value.
    
    Returns:
    
    the created assertion object.
  - then
```
public static <ELEMENT> SpliteratorAssert<ELEMENT> then(Spliterator<ELEMENT> actual)
```
    Creates a new instance of SpliteratorAssert from the given Spliterator. Example:
    Spliterator<Integer> spliterator = Stream.of(1, 2, 3).spliterator(); then(spliterator).hasCharacteristics(Spliterator.SIZED);
    Type Parameters:
    
    ELEMENT - the type of elements.
    
    Parameters:
    
    actual - the spliterator to test.
    
    Returns:
    
    the created assertion object.

Class BDDAssertions

Field Summary

Fields inherited from interface org.assertj.core.api.InstanceOfAssertFactories

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

and

Constructor Detail

BDDAssertions

Method Detail

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then

then