public class ObjectAssert<T> extends AbstractAssert<ObjectAssert<T>,T>
Object
s.
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, usingDefaultComparator
protected 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.