Class AbstractOptionalAssert<SELF extends AbstractOptionalAssert<SELF,​VALUE>,​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,​java.util.Optional<VALUE>>, Descriptable<SELF>, ExtensionPoints<SELF,​java.util.Optional<VALUE>>
    Direct Known Subclasses:
    OptionalAssert

    public abstract class AbstractOptionalAssert<SELF extends AbstractOptionalAssert<SELF,​VALUE>,​VALUE>
    extends AbstractAssert<SELF,​java.util.Optional<VALUE>>
    Assertions for Optional.
    • Field Detail

      • optionalValueComparisonStrategy

        private ComparisonStrategy optionalValueComparisonStrategy
    • Constructor Detail

      • AbstractOptionalAssert

        protected AbstractOptionalAssert​(java.util.Optional<VALUE> actual,
                                         java.lang.Class<?> selfType)
    • Method Detail

      • 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​(java.util.function.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> 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:
        java.lang.AssertionError - if the actual Optional is null or empty.
        java.lang.NullPointerException - if the given condition is null.
        java.lang.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​(java.lang.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​(java.util.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:
        java.lang.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​(java.util.function.Function<? super VALUE,​java.util.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:
        java.lang.AssertionError - if the actual Optional is null.
        Since:
        3.6.0
      • map

        public <U> AbstractOptionalAssert<?,​U> map​(java.util.function.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:
        java.lang.AssertionError - if the actual Optional is null.
        Since:
        3.6.0
      • checkNotNull

        private void checkNotNull​(java.lang.Object expectedValue)
      • assertValueIsPresent

        private void assertValueIsPresent()