Package org.assertj.core.api

Class Java6BDDAssertions

java.lang.Object
org.assertj.core.api.Java6BDDAssertions
@Deprecated public class Java6BDDAssertions extends Object
Deprecated.
For Android compatible assertions use the latest assertj 2.x version which is based on Java 7 only.

Android-compatible BDD-style assertions duplicated from BDDAssertions.

Since:
2.5.0 / 3.5.0
See Also:

  • Constructor Details

    • Java6BDDAssertions

      protected Java6BDDAssertions()
      Deprecated.
      Creates a new BDDAssertions.

  • Method Details

    • then

      public static AtomicBooleanAssert then(AtomicBoolean actual)
      Deprecated.
      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)
      Deprecated.
      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)
      Deprecated.
      Create int[] 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)
      Deprecated.
      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)
      Deprecated.
      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)
      Deprecated.
      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)
      Deprecated.
      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)
      Deprecated.
      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)
      Deprecated.
      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)
      Deprecated.
      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)
      Deprecated.
      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)
      Deprecated.
      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 AbstractBigDecimalAssert<?> then(BigDecimal actual)
      Deprecated.
      Creates a new instance of BigDecimalAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractBigIntegerAssert<?> then(BigInteger actual)
      Deprecated.
      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)
      Deprecated.
      Creates a new instance of BooleanAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractBooleanAssert<?> then(Boolean actual)
      Deprecated.
      Creates a new instance of BooleanAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractBooleanArrayAssert<?> then(boolean[] actual)
      Deprecated.
      Creates a new instance of BooleanArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static Boolean2DArrayAssert then(boolean[][] actual)
      Deprecated.
      Creates a new instance of Boolean2DArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.17.0

    • then

      public static AbstractByteAssert<?> then(byte actual)
      Deprecated.
      Creates a new instance of ByteAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractByteAssert<?> then(Byte actual)
      Deprecated.
      Creates a new instance of ByteAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractByteArrayAssert<?> then(byte[] actual)
      Deprecated.
      Creates a new instance of ByteArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static Byte2DArrayAssert then(byte[][] actual)
      Deprecated.
      Creates a new instance of Byte2DArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.17.0

    • then

      public static AbstractCharacterAssert<?> then(char actual)
      Deprecated.
      Creates a new instance of CharacterAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractCharArrayAssert<?> then(char[] actual)
      Deprecated.
      Creates a new instance of CharArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static Char2DArrayAssert then(char[][] actual)
      Deprecated.
      Creates a new instance of Char2DArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.17.0

    • then

      public static AbstractCharacterAssert<?> then(Character actual)
      Deprecated.
      Creates a new instance of CharacterAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractClassAssert<?> then(Class<?> actual)
      Deprecated.
      Creates a new instance of ClassAssert
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static <T> AbstractCollectionAssert<?,Collection<? extends T>,T,ObjectAssert<T>> then(Collection<? extends T> actual)
      Deprecated.
      Creates a new instance of CollectionAssert.
      Type Parameters:
      T - the actual elements type
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.21.0

    • then

      public static <T extends Comparable<? super T>> AbstractComparableAssert<?,T> then(T actual)
      Deprecated.
      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> AbstractIterableAssert<?,Iterable<? extends T>,T,ObjectAssert<T>> then(Iterable<? extends T> actual)
      Deprecated.
      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> AbstractIteratorAssert<?,T> then(Iterator<? extends T> actual)
      Deprecated.
      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

      @Deprecated 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)
      Deprecated.
      This was added to help creating type-specific assertions for the elements of an Iterable instance.

      Deprecated way: 

       Iterable<String> hobbits = Set.of("frodo", "sam", "Pippin");
 then(hobbits, StringAssert::new).first()
                                 .startsWith("fro")
                                 .endsWith("do");
      However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).

      New way: 

       then(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
              .startsWith("fro")
              .endsWith("do");
      The main advantage of the latter is easier discoverability and the use of InstanceOfAssertFactory which is the preferred way to create type-specific assertions in AssertJ API.
      Creates a new instance of FactoryBasedNavigableIterableAssert allowing to navigate to any Iterable element in order to perform assertions on it.

      Navigational methods provided:

      The available assertions after navigating to an element depend on the ELEMENT_ASSERT parameter of the given AssertFactory<ELEMENT, ELEMENT_ASSERT> (AssertJ can't figure it out because of Java type erasure).

      Example with String element assertions: 

       Iterable<String> hobbits = newHashSet("frodo", "sam", "pippin");

 // build an AssertFactory for StringAssert (much nicer with Java 8 lambdas)
 AssertFactory<String, StringAssert> stringAssertFactory = new AssertFactory<String, StringAssert>() {
   @Override
   public StringAssert createAssert(String string) {
     return new StringAssert(string);
   }
 };

 // assertion succeeds with String assertions chained after first()
 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

      @Deprecated 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)
      Deprecated.
      This was added to help creating type-specific assertions for the elements of an Iterable instance.

      Deprecated way: 

       Iterable<String> hobbits = Set.of("frodo", "sam", "Pippin");
 then(hobbits, StringAssert.class).first()
                                  .startsWith("fro")
                                  .endsWith("do");
      However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).

      New way: 

       then(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
              .startsWith("fro")
              .endsWith("do");
      The main advantage of the latter is easier discoverability and the use of InstanceOfAssertFactory which is the preferred way to create type-specific assertions in AssertJ API.
      Creates a new instance of ClassBasedNavigableIterableAssert allowing to navigate to any Iterable element in order to perform assertions on it.

      Navigational methods provided:

      The available assertions after navigating to an element depend on the given assertClass (AssertJ can't find the element assert type by itself because of Java type erasure).

      Example with String element assertions: 

       Iterable<String> hobbits = newHashSet("frodo", "sam", "pippin");

 // assertion succeeds with String assertions chained after first()
 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

      @Deprecated 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)
      Deprecated.
      This was added to help creating type-specific assertions for the elements of an List instance.

      Deprecated way: 

       List<String> hobbits = List.of("frodo", "sam", "Pippin");
 then(hobbits, StringAssert::new).first()
                                 .startsWith("fro")
                                 .endsWith("do");
      However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).

      New way: 

       then(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
              .startsWith("fro")
              .endsWith("do");
      The main advantage of the latter is easier discoverability and the use of InstanceOfAssertFactory which is the preferred way to create type-specific assertions in AssertJ API.
      Creates a new instance of FactoryBasedNavigableListAssert allowing to navigate to any List element in order to perform assertions on it.

      Navigational methods provided:

      The available assertions after navigating to an element depend on the ELEMENT_ASSERT parameter of the given AssertFactory<ELEMENT, ELEMENT_ASSERT> (AssertJ can't figure it out because of Java type erasure).

      Example with String element assertions: 

       List<String> hobbits = newArrayList("frodo", "sam", "pippin");

 // build an AssertFactory for StringAssert (much nicer with Java 8 lambdas)
 AssertFactory<String, StringAssert> stringAssertFactory = new AssertFactory<String, StringAssert>() {
   @Override
   public StringAssert createAssert(String string) {
     return new StringAssert(string);
   }
 };

 // assertion succeeds with String assertions chained after first()
 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

      @Deprecated 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)
      Deprecated.
      This was added to help creating type-specific assertions for the elements of an List instance.

      Deprecated way: 

       List<String> hobbits = List.of("frodo", "sam", "Pippin");
 then(hobbits, StringAssert.class).first()
                                  .startsWith("fro")
                                  .endsWith("do");
      However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).

      New way: 

       then(hobbits).first(STRING) // static import of InstanceOfAssertFactories.STRING
              .startsWith("fro")
              .endsWith("do");
      The main advantage of the latter is easier discoverability and the use of InstanceOfAssertFactory which is the preferred way to create type-specific assertions in AssertJ API.
      Creates a new instance of ClassBasedNavigableListAssert allowing to navigate to any List element in order to perform assertions on it.

      Navigational methods provided:

      The available assertions after navigating to an element depend on the given assertClass (AssertJ can't find the element assert type by itself because of Java type erasure).

      Example with String element assertions: 

       List<String> hobbits = newArrayList("frodo", "sam", "pippin");

 // assertion succeeds with String assertions chained after first()
 then(hobbits, StringAssert.class).first()
                                  .startsWith("fro")
                                  .endsWith("do");
      Type Parameters:
      ELEMENT - The actual elements type
      ACTUAL - The actual 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)
      Deprecated.
      Creates a new instance of DoubleAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractDoubleAssert<?> then(Double actual)
      Deprecated.
      Creates a new instance of DoubleAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractDoubleArrayAssert<?> then(double[] actual)
      Deprecated.
      Creates a new instance of DoubleArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static Double2DArrayAssert then(double[][] actual)
      Deprecated.
      Creates a new instance of Double2DArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.17.0

    • then

      public static AbstractFileAssert<?> then(File actual)
      Deprecated.
      Creates a new instance of FileAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static <RESULT> AbstractFutureAssert<?,? extends Future<? extends RESULT>,RESULT> then(Future<RESULT> actual)
      Deprecated.
      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)
      Deprecated.
      Creates a new instance of InputStreamAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractFloatAssert<?> then(float actual)
      Deprecated.
      Creates a new instance of FloatAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractFloatAssert<?> then(Float actual)
      Deprecated.
      Creates a new instance of FloatAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractFloatArrayAssert<?> then(float[] actual)
      Deprecated.
      Creates a new instance of FloatArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractIntegerAssert<?> then(int actual)
      Deprecated.
      Creates a new instance of IntegerAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractIntArrayAssert<?> then(int[] actual)
      Deprecated.
      Creates a new instance of IntArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static Int2DArrayAssert then(int[][] actual)
      Deprecated.
      Creates a new instance of Int2DArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static Float2DArrayAssert then(float[][] actual)
      Deprecated.
      Creates a new instance of Float2DArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.17.0

    • then

      public static AbstractIntegerAssert<?> then(Integer actual)
      Deprecated.
      Creates a new instance of IntegerAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static <T> AbstractListAssert<?,List<? extends T>,T,ObjectAssert<T>> then(List<? extends T> actual)
      Deprecated.
      Creates a new instance of ListAssert.
      Type Parameters:
      T - the actual elements type
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractLongAssert<?> then(long actual)
      Deprecated.
      Creates a new instance of LongAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractLongAssert<?> then(Long actual)
      Deprecated.
      Creates a new instance of LongAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractLongArrayAssert<?> then(long[] actual)
      Deprecated.
      Creates a new instance of LongArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static Long2DArrayAssert then(long[][] actual)
      Deprecated.
      Creates a new instance of Long2DArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.17.0

    • then

      public static <T> AbstractObjectAssert<?,T> then(T actual)
      Deprecated.
      Creates a new instance of ObjectAssert.
      Type Parameters:
      T - the actual type
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static <T> AbstractObjectArrayAssert<?,T> then(T[] actual)
      Deprecated.
      Creates a new instance of ObjectArrayAssert.
      Type Parameters:
      T - the actual elements type
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static <T> Object2DArrayAssert<T> then(T[][] actual)
      Deprecated.
      Creates a new instance of Object2DArrayAssert.
      Type Parameters:
      T - the actual elements type
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.17.0

    • then

      public static <K, V> MapAssert<K,V> then(Map<K,V> actual)
      Deprecated.
      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)
      Deprecated.
      Creates a new instance of ShortAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractShortAssert<?> then(Short actual)
      Deprecated.
      Creates a new instance of ShortAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractShortArrayAssert<?> then(short[] actual)
      Deprecated.
      Creates a new instance of ShortArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static Short2DArrayAssert then(short[][] actual)
      Deprecated.
      Creates a new instance of Short2DArrayAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.17.0

    • then

      public static AbstractCharSequenceAssert<?,? extends CharSequence> then(CharSequence actual)
      Deprecated.
      Creates a new instance of CharSequenceAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • thenCharSequence

      public static AbstractCharSequenceAssert<?,? extends CharSequence> thenCharSequence(CharSequence actual)
      Deprecated.
      Creates a new instance of CharSequenceAssert.

      Use this over then(CharSequence) in case of ambiguous method resolution when the object under test implements several interfaces Assertj provides then for.

      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.25.0

    • then

      public static AbstractCharSequenceAssert<?,? extends CharSequence> then(StringBuilder actual)
      Deprecated.
      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)
      Deprecated.
      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)
      Deprecated.
      Creates a new instance of StringAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractDateAssert<?> then(Date actual)
      Deprecated.
      Creates a new instance of DateAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static <T extends Throwable> AbstractThrowableAssert<?,T> then(T actual)
      Deprecated.
      Creates a new instance of ThrowableAssert.
      Type Parameters:
      T - the type of the actual throwable.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion Throwable.

    • thenThrownBy

      public static AbstractThrowableAssert<?,? extends Throwable> thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
      Deprecated.
      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");
  }
      Java 7 example : 
       thenThrownBy(new ThrowingCallable() {

   @Override
   public Void call() throws Exception {
     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(() -> {});
 then(thrown).as("display me")
             .isInstanceOf(Exception.class);
      Alternatively you can also use thenCode(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 captured exception or null if none was raised by the callable.

    • thenThrownBy

      public static AbstractThrowableAssert<?,? extends Throwable> thenThrownBy(ThrowableAssert.ThrowingCallable shouldRaiseThrowable, String description, Object... args)
      Deprecated.
      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 AbstractThrowableAssert<?,? extends Throwable> thenCode(ThrowableAssert.ThrowingCallable shouldRaiseOrNotThrowable)
      Deprecated.
      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();
      Contrary to thenThrownBy(ThrowingCallable) the test description provided with as(String, Object...) is always honored 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);

      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 AbstractUriAssert<?> then(URI actual)
      Deprecated.
      Creates a new instance of UriAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static AbstractUrlAssert<?> then(URL actual)
      Deprecated.
      Creates a new instance of UrlAssert.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • then

      public static <T extends AssertDelegateTarget> T then(T assertion)
      Deprecated.
      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)
      Deprecated.
      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

    • thenObject

      public static <T> AbstractObjectAssert<?,T> thenObject(T actual)
      Deprecated.
      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