Class AbstractOptionalAssert<SELF extends AbstractOptionalAssert<SELF,VALUE>,VALUE>

java.lang.Object
org.assertj.core.api.AbstractAssert<SELF,Optional<VALUE>>
org.assertj.core.api.AbstractOptionalAssert<SELF,VALUE>
Type Parameters:
SELF - the "self" type of this assertion class.
VALUE - type of the value contained in the Optional.
All Implemented Interfaces:
Assert<SELF,Optional<VALUE>>, Descriptable<SELF>, ExtensionPoints<SELF,Optional<VALUE>>
Direct Known Subclasses:
OptionalAssert

public abstract class AbstractOptionalAssert<SELF extends AbstractOptionalAssert<SELF,VALUE>,VALUE> extends AbstractAssert<SELF,Optional<VALUE>>
Assertions for Optional.
  • Field Details

    • optionalValueComparisonStrategy

      private ComparisonStrategy optionalValueComparisonStrategy
  • Constructor Details

    • AbstractOptionalAssert

      protected AbstractOptionalAssert(Optional<VALUE> actual, Class<?> selfType)
  • Method Details

    • isPresent

      public SELF isPresent()
      Verifies that there is a value present in the actual Optional.

      Assertion will pass :
       assertThat(Optional.of("something")).isPresent();
      Assertion will fail :
       assertThat(Optional.empty()).isPresent();
      Returns:
      this assertion object.
    • isNotEmpty

      public SELF isNotEmpty()
      Verifies that there is a value present in the actual Optional, it's an alias of isPresent().

      Assertion will pass :
       assertThat(Optional.of("something")).isNotEmpty();
      Assertion will fail :
       assertThat(Optional.empty()).isNotEmpty();
      Returns:
      this assertion object.
    • isEmpty

      public SELF isEmpty()
      Verifies that the actual Optional is empty.

      Assertion will pass :
       assertThat(Optional.empty()).isEmpty();
      Assertion will fail :
       assertThat(Optional.of("something")).isEmpty();
      Returns:
      this assertion object.
    • isNotPresent

      public SELF isNotPresent()
      Verifies that the actual Optional is empty (alias of isEmpty()).

      Assertion will pass :
       assertThat(Optional.empty()).isNotPresent();
      Assertion will fail :
       assertThat(Optional.of("something")).isNotPresent();
      Returns:
      this assertion object.
    • contains

      public SELF contains(VALUE expectedValue)
      Verifies that the actual Optional contains the given value (alias of hasValue(Object)).

      Assertion will pass :
       assertThat(Optional.of("something")).contains("something");
       assertThat(Optional.of(10)).contains(10);
      Assertion will fail :
       assertThat(Optional.of("something")).contains("something else");
       assertThat(Optional.of(20)).contains(10);
      Parameters:
      expectedValue - the expected value inside the Optional.
      Returns:
      this assertion object.
    • hasValueSatisfying

      public SELF hasValueSatisfying(Consumer<VALUE> requirement)
      Verifies that the actual Optional contains a value and gives this value to the given Consumer for further assertions. Should be used as a way of deeper asserting on the containing object, as further requirement(s) for the value.

      Assertions will pass :
       // one requirement 
       assertThat(Optional.of(10)).hasValueSatisfying(i -> { assertThat(i).isGreaterThan(9); });
      
       // multiple requirements
       assertThat(Optional.of(someString)).hasValueSatisfying(s -> {
         assertThat(s).isEqualTo("something");
         assertThat(s).startsWith("some");
         assertThat(s).endsWith("thing");
       }); 
      Assertions will fail :
       assertThat(Optional.of("something")).hasValueSatisfying(s -> {
           assertThat(s).isEqualTo("something else");
         });
      
       // fail because optional is empty, there is no value to perform assertion on  
       assertThat(Optional.empty()).hasValueSatisfying(o -> {});
      Parameters:
      requirement - to further assert on the object contained inside the Optional.
      Returns:
      this assertion object.
    • hasValueSatisfying

      public SELF hasValueSatisfying(Condition<? super VALUE> condition)
      Verifies that the actual Optional contains a value which satisfies the given Condition.

      Examples:

       Condition<TolkienCharacter&gt isAnElf = new Condition<>(character -> character.getRace() == ELF, "an elf"); 
       
       TolkienCharacter legolas = new TolkienCharacter("Legolas", 1000, ELF);
       TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
       
       // assertion succeeds
       assertThat(Optional.of(legolas)).hasValueSatisfying(isAnElf);
                                           
       // assertion fails
       assertThat(Optional.of(frodo)).hasValueSatisfying(isAnElf);
      Parameters:
      condition - the given condition.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Optional is null or empty.
      NullPointerException - if the given condition is null.
      AssertionError - if the actual value does not satisfy the given condition.
      Since:
      3.6.0
    • hasValue

      public SELF hasValue(VALUE expectedValue)
      Verifies that the actual Optional contains the given value (alias of contains(Object)).

      Assertion will pass :
       assertThat(Optional.of("something")).hasValue("something");
       assertThat(Optional.of(10)).contains(10);
      Assertion will fail :
       assertThat(Optional.of("something")).hasValue("something else");
       assertThat(Optional.of(20)).contains(10);
      Parameters:
      expectedValue - the expected value inside the Optional.
      Returns:
      this assertion object.
    • containsInstanceOf

      public SELF containsInstanceOf(Class<?> clazz)
      Verifies that the actual Optional contains a value that is an instance of the argument.

      Assertions will pass:
       assertThat(Optional.of("something")).containsInstanceOf(String.class)
                                           .containsInstanceOf(Object.class);
      
       assertThat(Optional.of(10)).containsInstanceOf(Integer.class);
      Assertion will fail:
       assertThat(Optional.of("something")).containsInstanceOf(Integer.class);
      Parameters:
      clazz - the expected class of the value inside the Optional.
      Returns:
      this assertion object.
    • usingFieldByFieldValueComparator

      public SELF usingFieldByFieldValueComparator()
      Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type A equals method to compare the Optional value's object for incoming assertion checks. Private fields are included but this can be disabled using Assertions.setAllowExtractingPrivateFields(boolean).

      This can be handy if equals method of the Optional value's object to compare does not suit you.

      Note that the comparison is not recursive, if one of the fields/properties is an Object, it will be compared to the other field/property using its equals method.

      Example:

       TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
       TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);
      
       // Fail if equals has not been overridden in TolkienCharacter as equals default implementation only compares references
       assertThat(Optional.of(frodo)).contains(frodoClone);
      
       // frodo and frodoClone are equals when doing a field by field comparison.
       assertThat(Optional.of(frodo)).usingFieldByFieldValueComparator().contains(frodoClone);
      Returns:
      this assertion object.
    • usingValueComparator

      public SELF usingValueComparator(Comparator<? super VALUE> customComparator)
      Use given custom comparator instead of relying on actual type A equals method to compare the Optional value's object for incoming assertion checks.

      Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default comparison strategy.

      Examples :

       TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
       TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);
      
       // Fail if equals has not been overridden in TolkienCharacter as equals default implementation only compares references
       assertThat(Optional.of(frodo)).contains(frodoClone);
      
       // frodo and frodoClone are equals when doing a field by field comparison.
       assertThat(Optional.of(frodo)).usingValueComparator(new FieldByFieldComparator()).contains(frodoClone);
      Parameters:
      customComparator - the comparator to use for incoming assertion checks.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given comparator is null.
    • usingDefaultValueComparator

      public SELF usingDefaultValueComparator()
      Revert to standard comparison for incoming assertion Optional value checks.

      This method should be used to disable a custom comparison strategy set by calling usingValueComparator(Comparator).

      Returns:
      this assertion object.
    • containsSame

      public SELF containsSame(VALUE expectedValue)
      Verifies that the actual Optional contains the instance given as an argument (i.e. it must be the same instance).

      Assertion will pass :
       String someString = "something";
       assertThat(Optional.of(someString)).containsSame(someString);
      
       // Java will create the same 'Integer' instance when boxing small ints
       assertThat(Optional.of(10)).containsSame(10);
      Assertion will fail :
       // not even equal:
       assertThat(Optional.of("something")).containsSame("something else");
       assertThat(Optional.of(20)).containsSame(10);
      
       // equal but not the same: 
       assertThat(Optional.of(new String("something"))).containsSame(new String("something"));
       assertThat(Optional.of(new Integer(10))).containsSame(new Integer(10));
      Parameters:
      expectedValue - the expected value inside the Optional.
      Returns:
      this assertion object.
    • flatMap

      public <U> AbstractOptionalAssert<?,U> flatMap(Function<? super VALUE,Optional<U>> mapper)
      Call flatMap on the Optional under test, assertions chained afterwards are performed on the Optional resulting from the flatMap call.

      Examples:

       Function<String, Optional<String>> UPPER_CASE_OPTIONAL_STRING = 
             s -> s == null ? Optional.empty() : Optional.of(s.toUpperCase());
       
       // assertions succeed
       assertThat(Optional.of("something")).contains("something")
                                           .flatMap(UPPER_CASE_OPTIONAL_STRING)
                                           .contains("SOMETHING");
                                           
       assertThat(Optional.<String>empty()).flatMap(UPPER_CASE_OPTIONAL_STRING)
                                           .isEmpty();
                                           
       assertThat(Optional.<String>ofNullable(null)).flatMap(UPPER_CASE_OPTIONAL_STRING)
                                                    .isEmpty();
                                           
       // assertion fails
       assertThat(Optional.of("something")).flatMap(UPPER_CASE_OPTIONAL_STRING)
                                           .contains("something");
      Parameters:
      mapper - the Function to use in the flatMap operation.
      Returns:
      a new AbstractOptionalAssert for assertions chaining on the flatMap of the Optional.
      Throws:
      AssertionError - if the actual Optional is null.
      Since:
      3.6.0
    • map

      public <U> AbstractOptionalAssert<?,U> map(Function<? super VALUE,? extends U> mapper)
      Call map on the Optional under test, assertions chained afterwards are performed on the Optional resulting from the map call.

      Examples:

       // assertions succeed 
       assertThat(Optional.<String>empty()).map(String::length)
                                           .isEmpty();
       
       assertThat(Optional.of("42")).contains("42")
                                    .map(String::length)
                                    .contains(2);
                                    
       // assertion fails
       assertThat(Optional.of("42")).map(String::length)
                                    .contains(3);
      Parameters:
      mapper - the Function to use in the map operation.
      Returns:
      a new AbstractOptionalAssert for assertions chaining on the map of the Optional.
      Throws:
      AssertionError - if the actual Optional is null.
      Since:
      3.6.0
    • checkNotNull

      private void checkNotNull(Object expectedValue)
    • assertValueIsPresent

      private void assertValueIsPresent()