Package org.assertj.core.api

Class Java6AbstractBDDSoftAssertions

    • Constructor Detail

      • Java6AbstractBDDSoftAssertions

        public Java6AbstractBDDSoftAssertions()

    • Method Detail

      • then

        public BooleanAssert then​(boolean actual)
        Creates a new instance of BooleanAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public BooleanAssert then​(Boolean actual)
        Creates a new instance of BooleanAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public BooleanArrayAssert then​(boolean[] actual)
        Creates a new instance of BooleanArrayAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public ByteAssert then​(byte actual)
        Creates a new instance of ByteAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public ByteAssert then​(Byte actual)
        Creates a new instance of ByteAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public ByteArrayAssert then​(byte[] actual)
        Creates a new instance of ByteArrayAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public CharacterAssert then​(char actual)
        Creates a new instance of CharacterAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public CharArrayAssert then​(char[] actual)
        Creates a new instance of CharArrayAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public <T extends Comparable<? super T>> AbstractComparableAssert<?,​T> then​(T actual)
        Creates a new instance of GenericComparableAssert with standard comparison semantics.
        Type Parameters:
        T - the type of actual.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public <T> ProxyableIterableAssert<T> then​(Iterable<? extends T> actual)
        Creates a new instance of IterableAssert.
        Type Parameters:
        T - the type of elements.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public <T> IteratorAssert<T> then​(Iterator<? extends T> actual)
        Creates a new instance of IteratorAssert.

        This is a breaking change in version 3.12.0: this method used to return an ProxyableIterableAssert.

        Type Parameters:
        T - the type of elements.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public DoubleAssert then​(double actual)
        Creates a new instance of DoubleAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public DoubleAssert then​(Double actual)
        Creates a new instance of DoubleAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public DoubleArrayAssert then​(double[] actual)
        Creates a new instance of DoubleArrayAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public FileAssert then​(File actual)
        Creates a new instance of FileAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public <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 actual value.
        Returns:
        the created assertion object.
        Since:
        2.7.0 / 3.7.0

      • then

        public FloatAssert then​(float actual)
        Creates a new instance of FloatAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public FloatAssert then​(Float actual)
        Creates a new instance of FloatAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public FloatArrayAssert then​(float[] actual)
        Creates a new instance of FloatArrayAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public IntegerAssert then​(int actual)
        Creates a new instance of IntegerAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

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

      • then

        public IntegerAssert then​(Integer actual)
        Creates a new instance of IntegerAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public <T> ProxyableListAssert<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 LongAssert then​(long actual)
        Creates a new instance of LongAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public LongAssert then​(Long actual)
        Creates a new instance of LongAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public LongArrayAssert then​(long[] actual)
        Creates a new instance of LongArrayAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public <T> ProxyableObjectAssert<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 <T> ProxyableObjectArrayAssert<T> then​(T[] actual)
        Creates a new instance of ObjectArrayAssert.
        Type Parameters:
        T - the type of elements.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public <K,​V> ProxyableMapAssert<K,​V> then​(Map<K,​V> actual)
        Creates a new instance of MapAssert.

        We don't return MapAssert as it has overridden methods to annotated with SafeVarargs.

        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 ShortAssert then​(short actual)
        Creates a new instance of ShortAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public ShortAssert then​(Short actual)
        Creates a new instance of ShortAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public ShortArrayAssert then​(short[] actual)
        Creates a new instance of ShortArrayAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public StringAssert then​(String actual)
        Creates a new instance of StringAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public DateAssert then​(Date actual)
        Creates a new instance of DateAssert.
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.

      • then

        public 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 <VALUE> AtomicReferenceAssert<VALUE> then​(AtomicReference<VALUE> actual)
        Create assertion for AtomicReference.
        Type Parameters:
        VALUE - the type of object referred to by this reference
        Parameters:
        actual - the actual value.
        Returns:
        the created assertion object.
        Since:
        2.7.0 / 3.7.0

      • thenThrownBy

        public AbstractThrowableAssert<?,​? extends Throwable> thenThrownBy​(ThrowableAssert.ThrowingCallable shouldRaiseThrowable)
        Allows to capture and then assert on a Throwable more easily when used with Java 8 lambdas.

        Java 8 example : 

         @Test
  public void testException() {
    BDDSoftAssertions softly = new BDDSoftAssertions();
    softly.thenThrownBy(() -> { throw new Exception("boom!"); }).isInstanceOf(Exception.class)
                                                                .hasMessageContaining("boom");
  }
        Java 7 example : 
         BDDSoftAssertions softly = new BDDSoftAssertions();
 softly.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
 softly.thenThrownBy(() -> {}).as("display me")
                              .isInstanceOf(Exception.class);

 // assertion will fail AND "display me" will appear in the error
 Throwable thrown = catchThrowable(() -> {});
 softly.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 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() {
    BDDSoftAssertions softly = new BDDSoftAssertions();
    // if this assertion failed (but it doesn't), the error message would start with [Test explosive code]
    softly.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
 softly.thenThrownBy(() -> {}).as("display me")
                              .isInstanceOf(Exception.class);

 // assertion will fail AND "display me" will appear in the error message
 softly.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)
        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

      • thenObject

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

      • then

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