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 forOptional
.- Author:
- Jean-Christophe Gay, Nicolai Parlog, Grzegorz Piwowarek
-
-
Field Summary
Fields Modifier and Type Field Description private ComparisonStrategy
optionalValueComparisonStrategy
-
Fields inherited from class org.assertj.core.api.AbstractAssert
actual, assertionErrorCreator, conditions, info, myself, objects, throwUnsupportedExceptionOnEquals
-
-
Constructor Summary
Constructors Modifier Constructor Description protected
AbstractOptionalAssert(Optional<VALUE> actual, Class<?> selfType)
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description private void
assertValueIsPresent()
private void
checkNotNull(Object expectedValue)
SELF
contains(VALUE expectedValue)
Verifies that the actualOptional
contains the given value (alias ofhasValue(Object)
).SELF
containsInstanceOf(Class<?> clazz)
Verifies that the actualOptional
contains a value that is an instance of the argument.SELF
containsSame(VALUE expectedValue)
Verifies that the actualOptional
contains the instance given as an argument (i.e.<U> AbstractOptionalAssert<?,U>
flatMap(Function<? super VALUE,Optional<U>> mapper)
CallflatMap
on theOptional
under test, assertions chained afterwards are performed on theOptional
resulting from the flatMap call.AbstractObjectAssert<?,VALUE>
get()
Verifies that the actualOptional
is notnull
and not empty and returns an Object assertion that allows chaining (object) assertions on the optional value.<ASSERT extends AbstractAssert<?,?>>
ASSERTget(InstanceOfAssertFactory<?,ASSERT> assertFactory)
Verifies that the actualOptional
is notnull
and not empty and returns an new assertion instance to chain assertions on the optional value.SELF
hasValue(VALUE expectedValue)
Verifies that the actualOptional
contains the given value (alias ofcontains(Object)
).SELF
hasValueSatisfying(Consumer<VALUE> requirement)
SELF
hasValueSatisfying(Condition<? super VALUE> condition)
private AbstractObjectAssert<?,VALUE>
internalGet()
SELF
isEmpty()
Verifies that the actualOptional
is empty.SELF
isNotEmpty()
Verifies that there is a value present in the actualOptional
, it's an alias ofisPresent()
.SELF
isNotPresent()
SELF
isPresent()
Verifies that there is a value present in the actualOptional
.<U> AbstractOptionalAssert<?,U>
map(Function<? super VALUE,? extends U> mapper)
Callmap
on theOptional
under test, assertions chained afterwards are performed on theOptional
resulting from the map call.SELF
usingDefaultValueComparator()
Revert to standard comparison for incoming assertionOptional
value checks.SELF
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.RecursiveComparisonAssert<?>
usingRecursiveComparison()
Enable using a recursive field by field comparison strategy when calling the chainedRecursiveComparisonAssert
,RecursiveComparisonAssert<?>
usingRecursiveComparison(RecursiveComparisonConfiguration recursiveComparisonConfiguration)
Same asusingRecursiveComparison()
but allows to specify your ownRecursiveComparisonConfiguration
.SELF
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
asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, extracting, extracting, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, 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, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOf, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, withAssertionState, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnError
-
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
-
Methods inherited from interface org.assertj.core.api.Descriptable
as, as, describedAs
-
-
-
-
Field Detail
-
optionalValueComparisonStrategy
private ComparisonStrategy optionalValueComparisonStrategy
-
-
Method Detail
-
isPresent
public SELF 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
public SELF 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
public SELF 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
public SELF 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
public SELF contains(VALUE expectedValue)
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
public SELF hasValueSatisfying(Consumer<VALUE> requirement)
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
public SELF hasValueSatisfying(Condition<? super VALUE> condition)
Verifies that the actualOptional
contains a value which satisfies the givenCondition
.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:
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
public SELF hasValue(VALUE expectedValue)
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
public SELF containsInstanceOf(Class<?> clazz)
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
public SELF 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
public SELF 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.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
public SELF 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
public SELF containsSame(VALUE expectedValue)
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
public <U> AbstractOptionalAssert<?,U> flatMap(Function<? super VALUE,Optional<U>> mapper)
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");
- Type Parameters:
U
- the type wrapped in theOptional
after theflatMap
operation.- 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
public <U> AbstractOptionalAssert<?,U> map(Function<? super VALUE,? extends U> mapper)
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);
- Type Parameters:
U
- the type wrapped in theOptional
after themap
operation.- 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
-
get
public AbstractObjectAssert<?,VALUE> get()
Verifies that the actualOptional
is notnull
and not empty and returns an Object assertion that allows chaining (object) assertions on the optional value.Note that it is only possible to return Object assertions after calling this method due to java generics limitations.
Example:
TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT); TolkienCharacter sam = new TolkienCharacter("Sam", 38, null); // assertion succeeds since all frodo's fields are set assertThat(Optional.of(frodo)).get().hasNoNullFieldsOrProperties(); // assertion does not succeed because sam does not have its race set assertThat(Optional.of(sam)).get().hasNoNullFieldsOrProperties();
- Returns:
- a new
AbstractObjectAssert
for assertions chaining on the value of the Optional. - Throws:
AssertionError
- if the actualOptional
is null.AssertionError
- if the actualOptional
is empty.- Since:
- 3.9.0
- See Also:
get(InstanceOfAssertFactory)
-
get
public <ASSERT extends AbstractAssert<?,?>> ASSERT get(InstanceOfAssertFactory<?,ASSERT> assertFactory)
Verifies that the actualOptional
is notnull
and not empty and returns an new assertion instance to chain assertions on the optional value.The
assertFactory
parameter allows to specify anInstanceOfAssertFactory
, which is used to get the assertions narrowed to the factory type.Wrapping the given
InstanceOfAssertFactory
withAssertions.as(InstanceOfAssertFactory)
makes the assertion more readable.Example:
// assertion succeeds assertThat(Optional.of("frodo")).get(as(InstanceOfAssertFactories.STRING)).startsWith("fro"); // assertion does not succeed because frodo is not an Integer assertThat(Optional.of("frodo")).get(as(InstanceOfAssertFactories.INTEGER)).isZero();
- Type Parameters:
ASSERT
- the type of the resultingAssert
- Parameters:
assertFactory
- the factory which verifies the type and creates the newAssert
- Returns:
- a new narrowed
Assert
instance for assertions chaining on the value of the Optional - Throws:
NullPointerException
- if the given factory isnull
AssertionError
- if the actualOptional
is nullAssertionError
- if the actualOptional
is empty- Since:
- 3.14.0
-
usingRecursiveComparison
public RecursiveComparisonAssert<?> usingRecursiveComparison()
Enable using a recursive field by field comparison strategy when calling the chainedRecursiveComparisonAssert
,Example:
A detailed documentation for the recursive comparison is available here: https://assertj.github.io/doc/#assertj-core-recursive-comparison.public class Person { String name; boolean hasPhd; } public class Doctor { String name; boolean hasPhd; } Doctor drSheldon = new Doctor("Sheldon Cooper", true); Person sheldon = new Person("Sheldon Cooper", true); Optional<Doctor> doctor = Optional.of(drSheldon); Optional<Person> person = Optional.of(sheldon); // assertion succeeds as both maps contains equivalent items. assertThat(doctor).usingRecursiveComparison() .isEqualTo(person); // assertion fails because leonard names are different. drSheldon.setName("Sheldon Kooper"); assertThat(doctor).usingRecursiveComparison() .isEqualTo(person);
The default recursive comparison behavior is
configured
as follows:- different types of iterable can be compared by default as in the example, this can be turned off by calling
withStrictTypeChecking
. - overridden equals methods are used in the comparison (unless stated otherwise - see https://assertj.github.io/doc/#assertj-core-recursive-comparison-ignoring-equals)
- the following types are compared with these comparators:
java.lang.Double
:DoubleComparator
with precision of 1.0E-15java.lang.Float
:FloatComparator
with precision of 1.0E-6- any comparators previously registered with
AbstractIterableAssert.usingComparatorForType(Comparator, Class)
- Overrides:
usingRecursiveComparison
in classAbstractAssert<SELF extends AbstractOptionalAssert<SELF,VALUE>,Optional<VALUE>>
- Returns:
- a new
RecursiveComparisonAssert
instance - See Also:
RecursiveComparisonConfiguration
- different types of iterable can be compared by default as in the example, this can be turned off by calling
-
usingRecursiveComparison
public RecursiveComparisonAssert<?> usingRecursiveComparison(RecursiveComparisonConfiguration recursiveComparisonConfiguration)
Same asusingRecursiveComparison()
but allows to specify your ownRecursiveComparisonConfiguration
.- Overrides:
usingRecursiveComparison
in classAbstractAssert<SELF extends AbstractOptionalAssert<SELF,VALUE>,Optional<VALUE>>
- Parameters:
recursiveComparisonConfiguration
- theRecursiveComparisonConfiguration
used in the chainedisEqualTo
assertion.- Returns:
- a new
RecursiveComparisonAssert
instance built with the givenRecursiveComparisonConfiguration
.
-
internalGet
private AbstractObjectAssert<?,VALUE> internalGet()
-
checkNotNull
private void checkNotNull(Object expectedValue)
-
assertValueIsPresent
private void assertValueIsPresent()
-
-