Package org.assertj.core.api
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 theOptional
.
- 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 Summary
FieldsFields inherited from class org.assertj.core.api.AbstractAssert
actual, conditions, info, myself, objects
-
Constructor Summary
ConstructorsModifierConstructorDescriptionprotected
AbstractOptionalAssert
(Optional<VALUE> actual, Class<?> selfType) -
Method Summary
Modifier and TypeMethodDescriptionprivate void
private void
checkNotNull
(Object expectedValue) Verifies that the actualOptional
contains the given value (alias ofhasValue(Object)
).containsInstanceOf
(Class<?> clazz) Verifies that the actualOptional
contains a value that is an instance of the argument.containsSame
(VALUE expectedValue) Verifies that the actualOptional
contains the instance given as an argument (i.e.<U> AbstractOptionalAssert
<?, U> CallflatMap
on theOptional
under test, assertions chained afterwards are performed on theOptional
resulting from the flatMap call.Verifies that the actualOptional
contains the given value (alias ofcontains(Object)
).hasValueSatisfying
(Consumer<VALUE> requirement) hasValueSatisfying
(Condition<? super VALUE> condition) isEmpty()
Verifies that the actualOptional
is empty.Verifies that there is a value present in the actualOptional
, it's an alias ofisPresent()
.Verifies that there is a value present in the actualOptional
.<U> AbstractOptionalAssert
<?, U> Callmap
on theOptional
under test, assertions chained afterwards are performed on theOptional
resulting from the map call.Revert to standard comparison for incoming assertionOptional
value checks.Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type Aequals
method to compare theOptional
value's object for incoming assertion checks.usingValueComparator
(Comparator<? super VALUE> customComparator) Use given custom comparator instead of relying on actual type Aequals
method to compare theOptional
value's object for incoming assertion checks.Methods inherited from class org.assertj.core.api.AbstractAssert
as, as, asList, asString, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasToString, inBinary, inHexadecimal, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, overridingErrorMessage, satisfies, setCustomRepresentation, throwAssertionError, usingComparator, usingDefaultComparator, withFailMessage, withRepresentation, withThreadDumpOnError
-
Field Details
-
optionalValueComparisonStrategy
-
-
Constructor Details
-
AbstractOptionalAssert
-
-
Method Details
-
isPresent
Verifies that there is a value present in the actualOptional
. Assertion will pass :
Assertion will fail :assertThat(Optional.of("something")).isPresent();
assertThat(Optional.empty()).isPresent();
- Returns:
- this assertion object.
-
isNotEmpty
Verifies that there is a value present in the actualOptional
, it's an alias ofisPresent()
. Assertion will pass :
Assertion will fail :assertThat(Optional.of("something")).isNotEmpty();
assertThat(Optional.empty()).isNotEmpty();
- Returns:
- this assertion object.
-
isEmpty
Verifies that the actualOptional
is empty. Assertion will pass :
Assertion will fail :assertThat(Optional.empty()).isEmpty();
assertThat(Optional.of("something")).isEmpty();
- Returns:
- this assertion object.
-
isNotPresent
Verifies that the actualOptional
is empty (alias ofisEmpty()
). Assertion will pass :
Assertion will fail :assertThat(Optional.empty()).isNotPresent();
assertThat(Optional.of("something")).isNotPresent();
- Returns:
- this assertion object.
-
contains
Verifies that the actualOptional
contains the given value (alias ofhasValue(Object)
). Assertion will pass :
Assertion will fail :assertThat(Optional.of("something")).contains("something"); assertThat(Optional.of(10)).contains(10);
assertThat(Optional.of("something")).contains("something else"); assertThat(Optional.of(20)).contains(10);
- Parameters:
expectedValue
- the expected value inside theOptional
.- Returns:
- this assertion object.
-
hasValueSatisfying
Verifies that the actualOptional
contains a value and gives this value to the givenConsumer
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 :
Assertions will fail :// 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"); });
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 theOptional
.- Returns:
- this assertion object.
-
hasValueSatisfying
Verifies that the actualOptional
contains a value which satisfies the givenCondition
.Examples:
Condition<TolkienCharacterinvalid input: '>' 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 actualOptional
is null or empty.NullPointerException
- if the given condition isnull
.AssertionError
- if the actual value does not satisfy the given condition.- Since:
- 3.6.0
-
hasValue
Verifies that the actualOptional
contains the given value (alias ofcontains(Object)
). Assertion will pass :
Assertion will fail :assertThat(Optional.of("something")).hasValue("something"); assertThat(Optional.of(10)).contains(10);
assertThat(Optional.of("something")).hasValue("something else"); assertThat(Optional.of(20)).contains(10);
- Parameters:
expectedValue
- the expected value inside theOptional
.- Returns:
- this assertion object.
-
containsInstanceOf
Verifies that the actualOptional
contains a value that is an instance of the argument. Assertions will pass:
Assertion will fail:assertThat(Optional.of("something")).containsInstanceOf(String.class) .containsInstanceOf(Object.class); assertThat(Optional.of(10)).containsInstanceOf(Integer.class);
assertThat(Optional.of("something")).containsInstanceOf(Integer.class);
- Parameters:
clazz
- the expected class of the value inside theOptional
.- Returns:
- this assertion object.
-
usingFieldByFieldValueComparator
Use field/property by field/property comparison (including inherited fields/properties) instead of relying on actual type Aequals
method to compare theOptional
value's object for incoming assertion checks. Private fields are included but this can be disabled usingAssertions.setAllowExtractingPrivateFields(boolean)
.This can be handy if
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 itsequals
method of theOptional
value's object to compare does not suit you.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
Use given custom comparator instead of relying on actual type Aequals
method to compare theOptional
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 isnull
.
-
usingDefaultValueComparator
Revert to standard comparison for incoming assertionOptional
value checks.This method should be used to disable a custom comparison strategy set by calling
usingValueComparator(Comparator)
.- Returns:
this
assertion object.
-
containsSame
Verifies that the actualOptional
contains the instance given as an argument (i.e. it must be the same instance). Assertion will pass :
Assertion will fail :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);
// 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 theOptional
.- Returns:
- this assertion object.
-
flatMap
CallflatMap
on theOptional
under test, assertions chained afterwards are performed on theOptional
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
- theFunction
to use in theflatMap
operation.- Returns:
- a new
AbstractOptionalAssert
for assertions chaining on the flatMap of the Optional. - Throws:
AssertionError
- if the actualOptional
is null.- Since:
- 3.6.0
-
map
Callmap
on theOptional
under test, assertions chained afterwards are performed on theOptional
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
- theFunction
to use in themap
operation.- Returns:
- a new
AbstractOptionalAssert
for assertions chaining on the map of the Optional. - Throws:
AssertionError
- if the actualOptional
is null.- Since:
- 3.6.0
-
checkNotNull
-
assertValueIsPresent
private void assertValueIsPresent()
-