public class ObjectAssert<T> extends AbstractAssert<ObjectAssert<T>,T>
Objects.
To create a new instance of this class, invoke Assertions.assertThat(Object)
actual, info, myself| Modifier | Constructor and Description |
|---|---|
protected |
ObjectAssert(T actual) |
| Modifier and Type | Method and Description |
|---|---|
ObjectAssert<T> |
isEqualsToByComparingFields(T other)
Assert that the actual object is equals fields by fields to another object, inherited fields are taken into
account.
|
ObjectAssert<T> |
isLenientEqualsToByAcceptingFields(T other,
String... fields)
Assert that the actual object is lenient equals to given one by only comparing actual and other on the given
"accepted" fields only ("accepted" fields can be inherited fields).
|
ObjectAssert<T> |
isLenientEqualsToByIgnoringFields(T other,
String... fields)
Assert that the actual object is lenient equals to given one by comparing actual and other fields (including
inherited fields) except the given "ignored" fields.
|
ObjectAssert<T> |
isLenientEqualsToByIgnoringNullFields(T other)
Assert that the actual object is lenient equals to given one by comparing only actual and not null other
fields (including inherited fields).
|
as, as, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, overridingErrorMessage, usingComparator, usingDefaultComparatorprotected ObjectAssert(T actual)
public ObjectAssert<T> isLenientEqualsToByIgnoringNullFields(T other)
It means that if an actual field is not null and the corresponding field in other is null, field will be ignored by lenient comparison, but the inverse will make assertion fail (null field in actual, not null in other).
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).isLenientEqualsToByIgnoringNullFields(mysteriousHobbit); //=> OK
// ... but the lenient equality is not reversible !
assertThat(mysteriousHobbit).isLenientEqualsToByIgnoringNullFields(frodo); //=> FAIL
other - the object to compare actual to.NullPointerException - if the actual type is null.NullPointerException - if the other type is null.AssertionError - if the actual and the given object are not lenient equals.AssertionError - if the other object is not an instance of the actual type.public ObjectAssert<T> isLenientEqualsToByAcceptingFields(T other, String... fields)
Example:
TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
TolkienCharacter sam = new TolkienCharacter("Sam", 38, HOBBIT);
// frodo and sam both are hobbits, so they are lenient equals on race
assertThat(frodo).isLenientEqualsToByAcceptingFields(sam, "race"); // => OK
// ... but not when accepting name and race
assertThat(frodo).isLenientEqualsToByAcceptingFields(sam, "name", "race"); // => FAIL
other - the object to compare actual to.fields - accepted fields for lenient equality.NullPointerException - if the actual type is null.NullPointerException - if the other type is null.AssertionError - if the actual and the given object are not lenient equals.AssertionError - if the other object is not an instance of the actual type.IntrospectionError - if a field does not exist in actual.public ObjectAssert<T> isLenientEqualsToByIgnoringFields(T other, String... fields)
Example:
TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
TolkienCharacter sam = new TolkienCharacter("Sam", 38, HOBBIT);
// frodo and sam both are lenient equals ignoring name and age since only remaining property is race and frodo and sam both are HOBBIT
assertThat(frodo).isLenientEqualsToByIgnoringFields(sam, "name", "age"); //=> OK
// ... but they are not lenient equals if only age is ignored because their names differ.
assertThat(frodo).isLenientEqualsToByIgnoringFields(sam, "age"); //=> FAIL
other - the object to compare actual to.fields - ignored fields for lenient equality.NullPointerException - if the actual type is null.NullPointerException - if the other type is null.AssertionError - if the actual and the given object are not lenient equals.AssertionError - if the other object is not an instance of the actual type.public ObjectAssert<T> isEqualsToByComparingFields(T other)
This can be handy if equals implementation of objects to compare does not suit you.
Example:
TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);
// Fail if equals has not been overriden in TolkienCharacter as equals default implementation only compares references
assertThat(frodo).isEqualsTo(frodoClone); // Fail if equals has not been overriden in TolkienCharacter
// frodo and frodoClone are equals by comparing fields
assertThat(frodo).isEqualsToByComparingFields(frodoClone); // OK
other - the object to compare actual to.NullPointerException - if the actual type is null.NullPointerException - if the other type is null.AssertionError - if the actual and the given object are not equals fields by fields.AssertionError - if the other object is not an instance of the actual type.Copyright © 2013 AssertJ. All Rights Reserved.