Class AbstractObjectAssert<SELF extends AbstractObjectAssert<SELF,ACTUAL>,ACTUAL>
- Type Parameters:
SELF
- the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.ACTUAL
- the type of the "actual" value.
- All Implemented Interfaces:
Assert<SELF,
,ACTUAL> Descriptable<SELF>
,ExtensionPoints<SELF,
ACTUAL>
- Direct Known Subclasses:
AbstractAtomicFieldUpdaterAssert
,AbstractAtomicReferenceAssert
,AbstractComparableAssert
,AbstractMapAssert
,AbstractThrowableAssert
,ObjectAssert
Object
s.-
Field Summary
FieldsModifier and TypeFieldDescriptionprivate Map<String,
Comparator<?>> private TypeComparators
private static final double
private static final float
Fields inherited from class org.assertj.core.api.AbstractAssert
actual, conditions, info, myself, objects
-
Constructor Summary
Constructors -
Method Summary
Modifier and TypeMethodDescriptionSets the description of the assertion that is going to be called after.as
(Description description) Sets the description of the assertion that is going to be called after.static TypeComparators
extracting
(String... propertiesOrFields) Extract the values of given fields/properties from the object under test into an array, this new array becoming the object under test.final AbstractObjectArrayAssert<?,
Object> extracting
(Function<? super ACTUAL, Object>... extractors) Use the givenFunction
s to extract the values from the object under test into an array, this new array becoming the object under test.hasFieldOrProperty
(String name) Assert that the actual object has the specified field or property.hasFieldOrPropertyWithValue
(String name, Object value) Assert that the actual object has the specified field or property with the given value.Assert that the actual object has no null fields or properties (inherited ones are taken into account).hasNoNullFieldsOrPropertiesExcept
(String... propertiesOrFieldsToIgnore) Assert that the actual object has no null fields or properties except for the given ones (inherited ones are taken into account).Assert that actual object is equal to the given object based on a property/field by property/field comparison (including inherited ones).Assert that the object under test (actual) is equal to the given object based on recursive a property/field by property/field comparison (including inherited ones).isEqualToComparingOnlyGivenFields
(Object other, String... propertiesOrFieldsUsedInComparison) Assert that the actual object is equal to the given one using a property/field by property/field comparison on the given properties/fields only (fields can be inherited fields or nested fields).isEqualToIgnoringGivenFields
(Object other, String... propertiesOrFieldsToIgnore) Assert that the actual object is equal to the given one by comparing their properties/fields except for the given ones (inherited ones are taken into account).Assert that the actual object is equal to the given one by comparing actual's properties/fields with other's not null properties/fields only (including inherited ones).<T> SELF
Verify that the object under test returns the given expected value from the givenFunction
, a typical usage is to pass a method reference to assert object's property.<T> SELF
usingComparatorForFields
(Comparator<T> comparator, String... propertiesOrFields) Allows to set a specific comparator to compare properties or fields with the given names.<T> SELF
usingComparatorForType
(Comparator<T> comparator, Class<T> type) Allows to set a specific comparator to compare properties or fields with the given type.Methods inherited from class org.assertj.core.api.AbstractAssert
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
-
DOUBLE_COMPARATOR_PRECISION
private static final double DOUBLE_COMPARATOR_PRECISION- See Also:
-
FLOAT_COMPARATOR_PRECISION
private static final float FLOAT_COMPARATOR_PRECISION- See Also:
-
comparatorByPropertyOrField
-
comparatorByType
-
-
Constructor Details
-
AbstractObjectAssert
-
-
Method Details
-
defaultTypeComparators
-
as
Description copied from class:AbstractAssert
Sets the description of the assertion that is going to be called after.You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
This overloaded version of "describedAs" offers more flexibility than the one taking a
String
by allowing users to pass their own implementation of a description. For example, a description that creates its value lazily, only when an assertion failure occurs.- Specified by:
as
in interfaceDescriptable<SELF extends AbstractObjectAssert<SELF,
ACTUAL>> - Overrides:
as
in classAbstractAssert<SELF extends AbstractObjectAssert<SELF,
ACTUAL>, ACTUAL> - Parameters:
description
- the new description to set.- Returns:
this
object.- See Also:
-
as
Description copied from class:AbstractAssert
Sets the description of the assertion that is going to be called after.You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
The description follows
String.format(String, Object...)
syntax.Example :
try { // set a bad age to Mr Frodo which is really 33 years old. frodo.setAge(50); // specify a test description (call as() before the assertion !), it supports String format syntax. assertThat(frodo.getAge()).as("check %s's age", frodo.getName()).isEqualTo(33); } catch (AssertionError e) { assertThat(e).hasMessage("[check Frodo's age] expected:<[33]> but was:<[50]>"); }
- Specified by:
as
in interfaceDescriptable<SELF extends AbstractObjectAssert<SELF,
ACTUAL>> - Overrides:
as
in classAbstractAssert<SELF extends AbstractObjectAssert<SELF,
ACTUAL>, ACTUAL> - Parameters:
description
- the new description to set.args
- optional parameter if description is a format String.- Returns:
this
object.- See Also:
-
isEqualToIgnoringNullFields
Assert that the actual object is equal to the given one by comparing actual's properties/fields with other's not null properties/fields only (including inherited ones).It means that if an actual field is not null and the corresponding field in other is null, this field will be ignored in comparison, but the opposite will make assertion fail (null field in actual, not null in other) as the field is used in the performed comparison and the values differ.
Note that comparison is not recursive, if one of the field is an Object, it will be compared to the other field using its
equals
method.If an object has a field and a property with the same name, the property value will be used over the field.
Private fields are used in comparison but this can be disabled using
Assertions.setAllowComparingPrivateFields(boolean)
, if disabled only accessible fields values are compared, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter.The objects to compare can be of different types but the properties/fields used in comparison must exist in both, for example if actual object has a name String field, it is expected other object to also have one.
Example:
TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT); TolkienCharacter mysteriousHobbit = new TolkienCharacter(null, 33, HOBBIT); // Null fields in other/expected object are ignored, the mysteriousHobbit has null name thus name is ignored assertThat(frodo).isEqualToIgnoringNullFields(mysteriousHobbit); // OK // ... but this is not reversible ! assertThat(mysteriousHobbit).isEqualToIgnoringNullFields(frodo); // FAIL
- Parameters:
other
- the object to compareactual
to.- Throws:
NullPointerException
- if the actual or other object isnull
.AssertionError
- if the actual and the given object are not lenient equals.IntrospectionError
- if one of actual's field to compare can't be found in the other object.
-
isEqualToComparingOnlyGivenFields
public SELF isEqualToComparingOnlyGivenFields(Object other, String... propertiesOrFieldsUsedInComparison) Assert that the actual object is equal to the given one using a property/field by property/field comparison on the given properties/fields only (fields can be inherited fields or nested fields). This can be handy ifequals
implementation of objects to compare does not suit you.Note that comparison is not recursive, if one of the field is an Object, it will be compared to the other field using its
equals
method.If an object has a field and a property with the same name, the property value will be used over the field.
Private fields are used in comparison but this can be disabled using
Assertions.setAllowComparingPrivateFields(boolean)
, if disabled only accessible fields values are compared, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter.The objects to compare can be of different types but the properties/fields used in comparison must exist in both, for example if actual object has a name String field, it is expected the other object to also have one.
Example:
TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT); TolkienCharacter sam = new TolkienCharacter("Sam", 38, HOBBIT); // frodo and sam both are hobbits, so they are equals when comparing only race assertThat(frodo).isEqualToComparingOnlyGivenFields(sam, "race"); // OK // they are also equals when comparing only race name (nested field). assertThat(frodo).isEqualToComparingOnlyGivenFields(sam, "race.name"); // OK // ... but not when comparing both name and race assertThat(frodo).isEqualToComparingOnlyGivenFields(sam, "name", "race"); // FAIL
- Parameters:
other
- the object to compareactual
to.propertiesOrFieldsUsedInComparison
- properties/fields used in comparison.- Throws:
NullPointerException
- if the actual or other isnull
.AssertionError
- if the actual and the given objects are not equals property/field by property/field on given fields.IntrospectionError
- if one of actual's property/field to compare can't be found in the other object.IntrospectionError
- if a property/field does not exist in actual.
-
isEqualToIgnoringGivenFields
Assert that the actual object is equal to the given one by comparing their properties/fields except for the given ones (inherited ones are taken into account). This can be handy ifequals
implementation of objects to compare does not suit you.Note that comparison is not recursive, if one of the property/field is an Object, it will be compared to the other field using its
equals
method.If an object has a field and a property with the same name, the property value will be used over the field.
Private fields are used in comparison but this can be disabled using
Assertions.setAllowComparingPrivateFields(boolean)
, if disabled only accessible fields values are compared, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter.The objects to compare can be of different types but the properties/fields used in comparison must exist in both, for example if actual object has a name String field, it is expected the other object to also have one.
Example:
TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT); TolkienCharacter sam = new TolkienCharacter("Sam", 38, HOBBIT); // frodo and sam are equals when ignoring name and age since the only remaining field is race which they share as HOBBIT. assertThat(frodo).isEqualToIgnoringGivenFields(sam, "name", "age"); // OK // ... but they are not equals if only age is ignored as their names differ. assertThat(frodo).isEqualToIgnoringGivenFields(sam, "age"); // FAIL
- Parameters:
other
- the object to compareactual
to.propertiesOrFieldsToIgnore
- ignored properties/fields to ignore in comparison.- Throws:
NullPointerException
- if the actual or given object isnull
.AssertionError
- if the actual and the given objects are not equals property/field by property/field after ignoring given fields.IntrospectionError
- if one of actual's property/field to compare can't be found in the other object.
-
hasNoNullFieldsOrProperties
Assert that the actual object has no null fields or properties (inherited ones are taken into account).If an object has a field and a property with the same name, the property value will be used over the field.
Private fields are checked but this can be disabled using
Assertions.setAllowComparingPrivateFields(boolean)
, if disabled only accessible fields values are checked, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter.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(frodo).hasNoNullFields(); // assertion succeeds because sam does not have its race set assertThat(sam).hasNoNullFields();
- Throws:
AssertionError
- if the actual object isnull
.AssertionError
- if some fields or properties of the actual object are null.- Since:
- 2.5.0 / 3.5.0
-
hasNoNullFieldsOrPropertiesExcept
Assert that the actual object has no null fields or properties except for the given ones (inherited ones are taken into account).If an object has a field and a property with the same name, the property value will be used over the field.
Private fields are checked but this can be disabled using
Assertions.setAllowComparingPrivateFields(boolean)
, if disabled only accessible fields values are checked, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter.Example:
TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, null); // assertion succeeds since frodo has only null field is race assertThat(frodo).hasNoNullFieldsExcept("race"); // ... but if we require the race field, the assertion fails assertThat(frodo).hasNoNullFieldsExcept("name", "age");
- Parameters:
propertiesOrFieldsToIgnore
- properties/fields that won't be checked for null.- Throws:
AssertionError
- if the actual object isnull
.AssertionError
- if some (non ignored) fields or properties of the actual object are null.- Since:
- 2.5.0 / 3.5.0
-
isEqualToComparingFieldByField
Assert that actual object is equal to the given object based on a property/field by property/field comparison (including inherited ones). This can be handy ifequals
implementation of objects to compare does not suit you.Note that comparison is not recursive, if one of the field is an Object, it will be compared to the other field using its
equals
method.If an object has a field and a property with the same name, the property value will be used over the field.
Private fields are used in comparison but this can be disabled using
Assertions.setAllowComparingPrivateFields(boolean)
, if disabled only accessible fields values are compared, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter.The objects to compare can be of different types but the properties/fields used in comparison must exist in both, for example if actual object has a name String field, it is expected the other object to also have one.
Example:
// equals not overridden in TolkienCharacter TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT); TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT); // Fail as equals compares object references assertThat(frodo).isEqualsTo(frodoClone); // frodo and frodoClone are equals when doing a field by field comparison. assertThat(frodo).isEqualToComparingFieldByField(frodoClone);
- Parameters:
other
- the object to compareactual
to.- Throws:
AssertionError
- if the actual object isnull
.AssertionError
- if the actual and the given objects are not equals property/field by property/field.IntrospectionError
- if one of actual's property/field to compare can't be found in the other object.
-
usingComparatorForFields
Allows to set a specific comparator to compare properties or fields with the given names. A typical usage is for comparing double/float fields with a given precision.Comparators specified by this method have precedence over comparators added by
usingComparatorForType(java.util.Comparator<T>, java.lang.Class<T>)
.The comparators specified by this method are only used for field by field comparison like
isEqualToComparingFieldByField(Object)
.Example:
public class TolkienCharacter { private String name; private double height; // constructor omitted } TolkienCharacter frodo = new TolkienCharacter("Frodo", 1.2); TolkienCharacter tallerFrodo = new TolkienCharacter("Frodo", 1.3); TolkienCharacter reallyTallFrodo = new TolkienCharacter("Frodo", 1.9); Comparator<Double> closeEnough = new Comparator<Double>() { double precision = 0.5; public int compare(Double d1, Double d2) { return Math.abs(d1 - d2) <= precision ? 0 : 1; } }; // assertions will pass assertThat(frodo).usingComparatorForFields(closeEnough, "height") .isEqualToComparingFieldByField(tallerFrodo); assertThat(frodo).usingComparatorForFields(closeEnough, "height") .isEqualToIgnoringNullFields(tallerFrodo); assertThat(frodo).usingComparatorForFields(closeEnough, "height") .isEqualToIgnoringGivenFields(tallerFrodo); assertThat(frodo).usingComparatorForFields(closeEnough, "height") .isEqualToComparingOnlyGivenFields(tallerFrodo); // assertion will fail assertThat(frodo).usingComparatorForFields(closeEnough, "height") .isEqualToComparingFieldByField(reallyTallFrodo);
- Parameters:
comparator
- theComparator
to usepropertiesOrFields
- the names of the properties and/or fields the comparator should be used for- Returns:
this
assertions object
-
usingComparatorForType
Allows to set a specific comparator to compare properties or fields with the given type. A typical usage is for comparing fields of numeric type at a given precision.Comparators specified by
usingComparatorForFields(java.util.Comparator<T>, java.lang.String...)
have precedence over comparators specified by this method.The comparators specified by this method are only used for field by field comparison like
isEqualToComparingFieldByField(Object)
.Example:
If multiple compatible comparators have been registered for a givenpublic class TolkienCharacter { private String name; private double height; // constructor omitted } TolkienCharacter frodo = new TolkienCharacter("Frodo", 1.2); TolkienCharacter tallerFrodo = new TolkienCharacter("Frodo", 1.3); TolkienCharacter reallyTallFrodo = new TolkienCharacter("Frodo", 1.9); Comparator<Double> closeEnough = new Comparator<Double>() { double precision = 0.5; public int compare(Double d1, Double d2) { return Math.abs(d1 - d2) <= precision ? 0 : 1; } }; // assertions will pass assertThat(frodo).usingComparatorForType(closeEnough, Double.class) .isEqualToComparingFieldByField(tallerFrodo); assertThat(frodo).usingComparatorForType(closeEnough, Double.class) .isEqualToIgnoringNullFields(tallerFrodo); assertThat(frodo).usingComparatorForType(closeEnough, Double.class) .isEqualToIgnoringGivenFields(tallerFrodo); assertThat(frodo).usingComparatorForType(closeEnough, Double.class) .isEqualToComparingOnlyGivenFields(tallerFrodo); // assertion will fail assertThat(frodo).usingComparatorForType(closeEnough, Double.class) .isEqualToComparingFieldByField(reallyTallFrodo);
type
, the closest in the inheritance chain to the giventype
is chosen in the following order:- The comparator for the exact given
type
- The comparator of a superclass of the given
type
- The comparator of an interface implemented by the given
type
- Parameters:
comparator
- theComparator
to usetype
- theClass
of the type the comparator should be used for- Returns:
this
assertions object
- The comparator for the exact given
-
hasFieldOrProperty
Assert that the actual object has the specified field or property.Private fields are matched by default but this can be changed by calling
Assertions.setAllowExtractingPrivateFields(false)
.Example:
public class TolkienCharacter { private String name; private int age; // constructor omitted public String getName() { return this.name; } } TolkienCharacter frodo = new TolkienCharacter("Frodo", 33); // assertions will pass : assertThat(frodo).hasFieldOrProperty("name") .hasFieldOrProperty("age"); // private field are matched by default // assertions will fail : assertThat(frodo).hasFieldOrProperty("not_exists"); assertThat(frodo).hasFieldOrProperty(null); // disable looking for private fields Assertions.setAllowExtractingPrivateFields(false); assertThat(frodo).hasFieldOrProperty("age");
- Parameters:
name
- the field/property name to check- Throws:
AssertionError
- if the actual object isnull
.IllegalArgumentException
- if name isnull
.AssertionError
- if the actual object has not the given field/property
-
hasFieldOrPropertyWithValue
Assert that the actual object has the specified field or property with the given value.Private fields are matched by default but this can be changed by calling
Assertions.setAllowExtractingPrivateFields(false)
.Example:
public class TolkienCharacter { private String name; private int age; // constructor omitted public String getName() { return this.name; } } TolkienCharacter frodo = new TolkienCharacter("Frodo", 33); TolkienCharacter noname = new TolkienCharacter(null, 33); // assertions will pass : assertThat(frodo).hasFieldOrProperty("name", "Frodo"); assertThat(frodo).hasFieldOrProperty("age", 33); assertThat(noname).hasFieldOrProperty("name", null); // assertions will fail : assertThat(frodo).hasFieldOrProperty("name", "not_equals"); assertThat(frodo).hasFieldOrProperty(null, 33); assertThat(frodo).hasFieldOrProperty("age", null); assertThat(noname).hasFieldOrProperty("name", "Frodo"); // disable extracting private fields Assertions.setAllowExtractingPrivateFields(false); assertThat(frodo).hasFieldOrProperty("age", 33);
- Parameters:
name
- the field/property name to checkvalue
- the field/property expected value- Throws:
AssertionError
- if the actual object isnull
.IllegalArgumentException
- if name isnull
.AssertionError
- if the actual object has not the given field/propertyAssertionError
- if the actual object has the given field/property but not with the expected value- See Also:
-
extracting
Extract the values of given fields/properties from the object under test into an array, this new array becoming the object under test.If you extract "id", "name" and "email" fields/properties then the array will contain the id, name and email values of the object under test, you can then perform array assertions on the extracted values.
Nested fields/properties are supported, specifying "adress.street.number" is equivalent to get the value corresponding to actual.getAdress().getStreet().getNumber()
Private fields can be extracted unless you call
Assertions.setAllowExtractingPrivateFields(false)
.If the object under test is a
Map
withString
keys, extracting will extract values matching the given fields/properties.Example:
A property with the given name is looked for first, if it doesn't exist then a field with the given name is looked for, if the field is not accessible (i.e. does not exist) an IntrospectionError is thrown.// Create frodo, setting its name, age and Race (Race having a name property) TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT); // let's verify Frodo's name, age and race name: assertThat(frodo).extracting("name", "age", "race.name") .containsExactly("Frodo", 33, "Hobbit");
Note that the order of extracted property/field values is consistent with the iteration order of the array under test.
- Parameters:
propertiesOrFields
- the properties/fields to extract from the initial object under test- Returns:
- a new assertion object whose object under test is the array containing the extracted properties/fields values
- Throws:
IntrospectionError
- if one of the given name does not match a field or property
-
extracting
@SafeVarargs public final AbstractObjectArrayAssert<?,Object> extracting(Function<? super ACTUAL, Object>... extractors) Use the givenFunction
s to extract the values from the object under test into an array, this new array becoming the object under test.If the given
Function
s extract the id, name and email values then the array will contain the id, name and email values of the object under test, you can then perform array assertions on the extracted values.Example:
// Create frodo, setting its name, age and Race (Race having a name property) TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT); // let's verify Frodo's name, age and race name: assertThat(frodo).extracting(TolkienCharacter::getName, character -> character.age, // public field character -> character.getRace().getName()) .containsExactly("Frodo", 33, "Hobbit");
Note that the order of extracted values is consistent with the iteration order of the array under test.
- Parameters:
extractors
- the extractor functions to extract a value from an element of the Iterable under test.- Returns:
- a new assertion object whose object under test is the array containing the extracted values
-
isEqualToComparingFieldByFieldRecursively
Assert that the object under test (actual) is equal to the given object based on recursive a property/field by property/field comparison (including inherited ones). This can be useful if actual'sequals
implementation does not suit you. The recursive property/field comparison is not applied on fields having a customequals
implementation, i.e. the overriddenequals
method will be used instead of a field by field comparison.The recursive comparison handles cycles. By default
floats
are compared with a precision of 1.0E-6 anddoubles
with 1.0E-15.You can specify a custom comparator per (nested) fields or type with respectively
usingComparatorForFields(Comparator, String...)
andusingComparatorForType(Comparator, Class)
.The objects to compare can be of different types but must have the same properties/fields. For example if actual object has a name String field, it is expected the other object to also have one. If an object has a field and a property with the same name, the property value will be used over the field.
Example:
public class Person { public String name; public double height; public Home home = new Home(); public Person bestFriend; // constructor with name and height omitted for brevity } public class Home { public Address address = new Address(); } public static class Address { public int number = 1; } Person jack = new Person("Jack", 1.80); jack.home.address.number = 123; Person jackClone = new Person("Jack", 1.80); jackClone.home.address.number = 123; // cycle are handled in comparison jack.bestFriend = jackClone; jackClone.bestFriend = jack; // will fail as equals compares object references assertThat(jack).isEqualsTo(jackClone); // jack and jackClone are equals when doing a recursive field by field comparison assertThat(jack).isEqualToComparingFieldByFieldRecursively(jackClone); // any type/field can be compared with a a specific comparator. // let's change jack's height a little bit jack.height = 1.81; // assertion fails because of the height difference // (the default precision comparison for double is 1.0E-15) assertThat(jack).isEqualToComparingFieldByFieldRecursively(jackClone); // this succeeds because we allow a 0.5 tolerance on double assertThat(jack).usingComparatorForType(new DoubleComparator(0.5), Double.class) .isEqualToComparingFieldByFieldRecursively(jackClone); // you can set a comparator on specific fields (nested fields are supported) assertThat(jack).usingComparatorForFields(new DoubleComparator(0.5), "height") .isEqualToComparingFieldByFieldRecursively(jackClone);
- Parameters:
other
- the object to compareactual
to.- Throws:
AssertionError
- if the actual object isnull
.AssertionError
- if the actual and the given objects are not deeply equal property/field by property/field.IntrospectionError
- if one property/field to compare can not be found.
-
returns
Verify that the object under test returns the given expected value from the givenFunction
, a typical usage is to pass a method reference to assert object's property.Wrapping the given
Function
withAssertions.from(Function)
makes the assertion more readable.Example:
// from is not mandatory but it makes the assertions more readable assertThat(frodo).returns("Frodo", from(TolkienCharacter::getName)) .returns("Frodo", TolkienCharacter::getName) // no from :( .returns(HOBBIT, from(TolkienCharacter::getRace));
- Type Parameters:
T
- the expected value type the givenmethod
returns.- Parameters:
expected
- the value the object under test method's call should return.from
-Function
used to acquire the value to test from the object under test. Must not benull
- Returns:
this
assertion object.- Throws:
NullPointerException
- if givenfrom
function is null
-