Package org.assertj.core.api

Class AssertionsForInterfaceTypes

java.lang.Object
org.assertj.core.api.AssertionsForClassTypes
org.assertj.core.api.AssertionsForInterfaceTypes
public class AssertionsForInterfaceTypes extends AssertionsForClassTypes
Entry point for assertion methods for different data types. Each method in this class is a static factory for the type-specific assertion objects. The purpose of this class is to make test code more readable.

For example: 

 int removed = employees.removeFired();
 assertThat(removed).isZero();

 List<Employee> newEmployees = employees.hired(TODAY);
 assertThat(newEmployees).hasSize(6);
Java 8 is picky when choosing the right assertThat method if the object under test is generic and bounded, for example if foo is instance of T that extends Exception, java 8 will complain that it can't resolve the proper assertThat method (normally assertThat(Throwable) as foo might implement an interface like List, if that occurred assertThat(List) would also be a possible choice - thus confusing java 8.

This why Assertions have been split in AssertionsForClassTypes and AssertionsForInterfaceTypes (see http://stackoverflow.com/questions/29499847/ambiguous-method-in-java-8-why).

Author:
Alex Ruiz, Yvonne Wang, David DIDIER, Ted Young, Joel Costigliola, Matthieu Baechler, Mikhail Mazursky, Nicolas François, Julien Meddah, William Bakker, William Delanoue, Turbo87, dorzey

  • Constructor Details

    • AssertionsForInterfaceTypes

      protected AssertionsForInterfaceTypes()
      Creates a new Assertions.

  • Method Details

    • assertThat

      public static <T> T assertThat(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

    • assertThat

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

    • assertThat

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

    • assertThatIterable

      public static <ELEMENT> IterableAssert<ELEMENT> assertThatIterable(Iterable<? extends ELEMENT> actual)
      Creates a new instance of IterableAssert.

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

      Type Parameters:
      ELEMENT - the type of elements.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.23.0

    • assertThat

      public static <ELEMENT> IteratorAssert<ELEMENT> assertThat(Iterator<? extends ELEMENT> actual)
      Creates a new instance of IteratorAssert.
      Type Parameters:
      ELEMENT - the type of elements.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • assertThatIterator

      public static <ELEMENT> IteratorAssert<ELEMENT> assertThatIterator(Iterator<? extends ELEMENT> actual)
      Creates a new instance of IteratorAssert.

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

      Type Parameters:
      ELEMENT - the type of elements.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.23.0

    • assertThat

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

    • assertThatCollection

      public static <E> AbstractCollectionAssert<?,Collection<? extends E>,E,ObjectAssert<E>> assertThatCollection(Collection<? extends E> actual)
      Creates a new instance of CollectionAssert.

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

      Type Parameters:
      E - the type of elements.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.23.0

    • assertThat

      public static <ELEMENT> ListAssert<ELEMENT> assertThat(List<? extends ELEMENT> actual)
      Creates a new instance of ListAssert.
      Type Parameters:
      ELEMENT - the type of elements.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.

    • assertThatList

      public static <ELEMENT> ListAssert<ELEMENT> assertThatList(List<? extends ELEMENT> actual)
      Creates a new instance of ListAssert.

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

      Type Parameters:
      ELEMENT - the type of elements.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.23.0

    • assertThat

      public static <ELEMENT> ListAssert<ELEMENT> assertThat(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
 assertThat(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.
 assertThat(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);
 assertThat(stream).isEqualTo(stream)
                   .isSameAs(stream);
      Type Parameters:
      ELEMENT - the type of elements.
      Parameters:
      actual - the actual Stream value.
      Returns:
      the created assertion object.

    • assertThatStream

      public static <ELEMENT> ListAssert<ELEMENT> assertThatStream(Stream<? extends ELEMENT> actual)
      Creates a new instance of ListAssert from the given Stream.

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

      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
 assertThat(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.
 assertThat(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);
 assertThat(stream).isEqualTo(stream)
                   .isSameAs(stream);
      Type Parameters:
      ELEMENT - the type of elements.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.23.0

    • assertThat

      public static ListAssert<Double> assertThat(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
 assertThat(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.
 assertThat(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);
 assertThat(stream).isEqualTo(stream)
                   .isSameAs(stream);
      Parameters:
      actual - the actual DoubleStream value.
      Returns:
      the created assertion object.

    • assertThat

      public static ListAssert<Long> assertThat(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
 assertThat(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.
 assertThat(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);
 assertThat(stream).isEqualTo(stream)
                   .isSameAs(stream);
      Parameters:
      actual - the actual LongStream value.
      Returns:
      the created assertion object.

    • assertThat

      public static ListAssert<Integer> assertThat(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
 assertThat(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.
 assertThat(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);
 assertThat(stream).isEqualTo(stream)
                   .isSameAs(stream);
      Parameters:
      actual - the actual IntStream value.
      Returns:
      the created assertion object.

    • assertThat

      @Deprecated public static <ACTUAL extends Iterable<? extends ELEMENT>, ELEMENT, ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT, ELEMENT>> FactoryBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(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");
 assertThat(hobbits, StringAssert::new).first()
                                       .startsWith("fro")
                                       .endsWith("do");
      However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).

      New way: 

       assertThat(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 IterableAssert.
      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.

    • assertThat

      @Deprecated public static <ACTUAL extends Iterable<? extends ELEMENT>, ELEMENT, ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT, ELEMENT>> ClassBasedNavigableIterableAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(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");
 assertThat(hobbits, StringAssert.class).first()
                                        .startsWith("fro")
                                        .endsWith("do");
      However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).

      New way: 

       assertThat(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.

    • assertThat

      @Deprecated public static <ACTUAL extends List<? extends ELEMENT>, ELEMENT, ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT, ELEMENT>> FactoryBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(List<? 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: 

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

      New way: 

       assertThat(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.

    • assertThat

      @Deprecated public static <ELEMENT, ACTUAL extends List<? extends ELEMENT>, ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT, ELEMENT>> ClassBasedNavigableListAssert<?,ACTUAL,ELEMENT,ELEMENT_ASSERT> assertThat(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");
 assertThat(hobbits, StringAssert.class).first()
                                        .startsWith("fro")
                                        .endsWith("do");
      However, there is a better way with InstanceOfAssertFactory and the corresponding first(InstanceOfAssertFactory).

      New way: 

       assertThat(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.

    • assertThat

      public static AbstractPathAssert<?> assertThat(Path actual)
      Creates a new instance of PathAssert
      Parameters:
      actual - the path to test
      Returns:
      the created assertion object

    • assertThatPath

      public static AbstractPathAssert<?> assertThatPath(Path actual)
      Creates a new instance of PathAssert

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

      Parameters:
      actual - the path to test
      Returns:
      the created assertion object
      Since:
      3.23.0

    • assertThat

      public static <K, V> MapAssert<K,V> assertThat(Map<K,V> actual)
      Creates a new instance of MapAssert.

      Returned type is MapAssert as it overrides method to annotate them with SafeVarargs avoiding annoying warnings.

      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.

    • assertThat

      public static <T extends Comparable<? super T>> AbstractComparableAssert<?,T> assertThat(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.

    • assertThatComparable

      public static <T> AbstractUniversalComparableAssert<?,T> assertThatComparable(Comparable<T> actual)
      Creates a new instance of UniversalComparableAssert with standard comparison semantics.

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

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

    • assertThat

      public static <T extends AssertDelegateTarget> T assertThat(T assertion)
      Returns the given assertion. This method improves code readability by surrounding the given assertion with assertThat.

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

   void isNotBlinking() {
     // standard assertion from core Assertions.assertThat
     assertThat(button.isBlinking()).isFalse();
   }
 }
      As MyButtonAssert implements AssertDelegateTarget, you can use assertThat(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 assertThat
   assertThat(buttonAssert).isNotBlinking(); // same as : buttonAssert.isNotBlinking();

   button.setBlinking(true);

   assertThat(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.

    • assertThat

      public static <T> PredicateAssert<T> assertThat(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

    • assertThatPredicate

      public static <T> PredicateAssert<T> assertThatPredicate(Predicate<T> actual)
      Create assertion for Predicate.

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

      Type Parameters:
      T - the type of the value contained in the Predicate.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.23.0

    • assertThat

      public static IntPredicateAssert assertThat(IntPredicate actual)
      Create assertion for IntPredicate.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.5.0

    • assertThat

      public static LongPredicateAssert assertThat(LongPredicate actual)
      Create assertion for LongPredicate.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.5.0

    • assertThat

      public static DoublePredicateAssert assertThat(DoublePredicate actual)
      Create assertion for DoublePredicate.
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.
      Since:
      3.5.0

    • assertThat

      public static <RESULT> CompletableFutureAssert<RESULT> assertThat(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.

    • assertThat

      public static <ELEMENT> SpliteratorAssert<ELEMENT> assertThat(Spliterator<ELEMENT> actual)
      Create assertion for SpliteratorAssert.
      Type Parameters:
      ELEMENT - the type of elements
      Parameters:
      actual - the actual value.
      Returns:
      the created assertion object.