org.fest.assertions.api
Class ObjectAssert<T>

java.lang.Object
  extended by org.fest.assertions.api.AbstractAssert<ObjectAssert<T>,T>
      extended by org.fest.assertions.api.ObjectAssert<T>
All Implemented Interfaces:
Assert<ObjectAssert<T>,T>, Descriptable<ObjectAssert<T>>, ExtensionPoints<ObjectAssert<T>,T>

public class ObjectAssert<T>
extends AbstractAssert<ObjectAssert<T>,T>

Assertion methods for Objects.

To create a new instance of this class, invoke Assertions.assertThat(Object).

Author:
Yvonne Wang, Alex Ruiz, Nicolas François, Mikhail Mazursky

Field Summary
 
Fields inherited from class org.fest.assertions.api.AbstractAssert
actual, myself
 
Constructor Summary
protected ObjectAssert(T actual)
           
 
Method Summary
 ObjectAssert<T> isEqualsToByComparingFields(T other)
          Assert that the actual object is equals fields by fields to another object.
 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.
 ObjectAssert<T> isLenientEqualsToByIgnoringFields(T other, String... fields)
          Assert that the actual object is lenient equals to given one by comparing actual and other fields except the given "ignored" fields.
 ObjectAssert<T> isLenientEqualsToByIgnoringNullFields(T other)
          Assert that the actual object is lenient equals to given one by only comparing actual and not null other fields.
 
Methods inherited from class org.fest.assertions.api.AbstractAssert
as, as, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, has, hashCode, hasSameClassAs, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, usingComparator, usingDefaultComparator
 
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

ObjectAssert

protected ObjectAssert(T actual)
Method Detail

isLenientEqualsToByIgnoringNullFields

public ObjectAssert<T> isLenientEqualsToByIgnoringNullFields(T other)
Assert that the actual object is lenient equals to given one by only comparing actual and not null other fields.

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
 
 

Parameters:
other - the object to compare actual to.
Throws:
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.

isLenientEqualsToByAcceptingFields

public 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.
 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
 
 

Parameters:
other - the object to compare actual to.
fields - accepted fields for lenient equality.
Throws:
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.
org.fest.util.IntrospectionError - if a field does not exist in actual.

isLenientEqualsToByIgnoringFields

public ObjectAssert<T> isLenientEqualsToByIgnoringFields(T other,
                                                         String... fields)
Assert that the actual object is lenient equals to given one by comparing actual and other fields except the given "ignored" 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
 
 

Parameters:
other - the object to compare actual to.
fields - ignored fields for lenient equality.
Throws:
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.

isEqualsToByComparingFields

public ObjectAssert<T> isEqualsToByComparingFields(T other)
Assert that the actual object is equals fields by fields to another object.
 Example: 
 
 TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT); 
 TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT); 
 
 // frodo and frodoClone are equals by comparing fields
 assertThat(frodo).isLenientEqualsToByIgnoringFields(frodoClone); //=> OK
 
 

Parameters:
other - the object to compare actual to.
Throws:
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 © 2007-2012 FEST (Fixtures for Easy Software Testing). All Rights Reserved.