org.assertj.core.api.recursive.comparison

Class RecursiveComparisonConfiguration

java.lang.Object

org.assertj.core.api.recursive.comparison.RecursiveComparisonConfiguration

public class RecursiveComparisonConfiguration
extends Object

Field Summary

Fields

Modifier and Type	Field and Description
static String	INDENT_LEVEL_2

Constructor Summary

Constructors

Constructor and Description
RecursiveComparisonConfiguration()

Method Summary

Modifier and Type	Method and Description
Stream<Map.Entry<FieldLocation,Comparator<?>>>	comparatorByFields()
Comparator<?>	getComparatorForField(String fieldName)
Comparator<?>	getComparatorForType(Class<?> fieldType)
FieldComparators	getFieldComparators()
Set<FieldLocation>	getIgnoredFields() Returns the list of the object under test fields to ignore in the recursive comparison.
List<Pattern>	getIgnoredFieldsRegexes()
List<FieldLocation>	getIgnoredOverriddenEqualsForFields()
List<Class<?>>	getIgnoredOverriddenEqualsForTypes()
List<Pattern>	getIgnoredOverriddenEqualsRegexes()
TypeComparators	getTypeComparators()
boolean	hasComparatorForField(String fieldName)
boolean	hasComparatorForType(Class<?> keyType)
boolean	hasCustomComparators()
void	ignoreAllOverriddenEquals() Force a recursive comparison on all fields (except java types).
void	ignoreFields(String... fieldsToIgnore) Adds the given fields to the list of the object under test fields to ignore in the recursive comparison.
void	ignoreFieldsMatchingRegexes(String... regexes) Allows to ignore in the recursive comparison the object under test fields matching the given regexes.
void	ignoreOverriddenEqualsForFields(String... fields) Adds the given fields to the list of fields to force a recursive comparison on.
void	ignoreOverriddenEqualsForFieldsMatchingRegexes(String... regexes) Adds the given regexes to the list of regexes used find the fields to force a recursive comparison on.
void	ignoreOverriddenEqualsForTypes(Class<?>... types) Adds the given types to the list of types to force a recursive comparison on.
boolean	isInStrictTypeCheckingMode()
String	multiLineDescription(Representation representation)
void	registerComparatorForField(Comparator<?> comparator, FieldLocation fieldLocation) Registers the given Comparator to compare the fields with the given locations.
<T> void	registerComparatorForType(Comparator<? super T> comparator, Class<T> type) Registers the given Comparator to compare the fields with the given type.
void	setIgnoreAllActualNullFields(boolean ignoreAllActualNullFields) Sets whether actual null fields are ignored in the recursive comparison.
void	strictTypeChecking(boolean strictTypeChecking) Sets whether the recursive comparison will check that actual's type is compatible with expected's type (the same applies for each field).
String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

INDENT_LEVEL_2

public static final String INDENT_LEVEL_2

See Also:

Constant Field Values

Constructor Detail

RecursiveComparisonConfiguration

public RecursiveComparisonConfiguration()

Method Detail

hasComparatorForField

public boolean hasComparatorForField(String fieldName)

getComparatorForField

public Comparator<?> getComparatorForField(String fieldName)

getFieldComparators

public FieldComparators getFieldComparators()

hasComparatorForType

public boolean hasComparatorForType(Class<?> keyType)

hasCustomComparators

public boolean hasCustomComparators()

getComparatorForType

public Comparator<?> getComparatorForType(Class<?> fieldType)

getTypeComparators

public TypeComparators getTypeComparators()

setIgnoreAllActualNullFields

public void setIgnoreAllActualNullFields(boolean ignoreAllActualNullFields)

Sets whether actual null fields are ignored in the recursive comparison.

See RecursiveComparisonAssert.ignoringActualNullFields() for code examples.

Parameters:

ignoreAllActualNullFields - whether to ingore actual null fields in the recursive comparison

ignoreFields

public void ignoreFields(String... fieldsToIgnore)

Adds the given fields to the list of the object under test fields to ignore in the recursive comparison.

See RecursiveComparisonAssert#ignoringFields(String...) for examples.

Parameters:

fieldsToIgnore - the fields of the object under test to ignore in the comparison.

ignoreFieldsMatchingRegexes

public void ignoreFieldsMatchingRegexes(String... regexes)

Allows to ignore in the recursive comparison the object under test fields matching the given regexes. The given regexes are added to the already registered ones.

See RecursiveComparisonAssert#ignoringFieldsMatchingRegexes(String...) for examples.

Parameters:

regexes - regexes used to ignore fields in the comparison.

getIgnoredFields

public Set<FieldLocation> getIgnoredFields()

Returns the list of the object under test fields to ignore in the recursive comparison.

Returns:

the list of the object under test fields to ignore in the recursive comparison.

ignoreAllOverriddenEquals

public void ignoreAllOverriddenEquals()

Force a recursive comparison on all fields (except java types).

See RecursiveComparisonAssert.ignoringAllOverriddenEquals() for examples.

ignoreOverriddenEqualsForFields

public void ignoreOverriddenEqualsForFields(String... fields)

Adds the given fields to the list of fields to force a recursive comparison on.

See RecursiveComparisonAssert#ignoringOverriddenEqualsForFields(String...) for examples.

Parameters:

fields - the fields to force a recursive comparison on.

ignoreOverriddenEqualsForFieldsMatchingRegexes

public void ignoreOverriddenEqualsForFieldsMatchingRegexes(String... regexes)

Adds the given regexes to the list of regexes used find the fields to force a recursive comparison on.

See RecursiveComparisonAssert#ignoringOverriddenEqualsForFieldsMatchingRegexes(String...) for examples.

Parameters:

regexes - regexes used to specify the fields we want to force a recursive comparison on.

ignoreOverriddenEqualsForTypes

public void ignoreOverriddenEqualsForTypes(Class<?>... types)

Adds the given types to the list of types to force a recursive comparison on.

See RecursiveComparisonAssert#ignoringOverriddenEqualsForTypes(Class...) for examples.

Parameters:

types - the types to the list of types to force a recursive comparison on.

registerComparatorForType

public <T> void registerComparatorForType(Comparator<? super T> comparator,
                                          Class<T> type)

Registers the given Comparator to compare the fields with the given type.

Comparators specified by this method have less precedence than comparators added with registerComparatorForField(Comparator, FieldLocation).

See RecursiveComparisonAssert.withComparatorForType(Comparator, Class) for examples.

Type Parameters:

T - the class type to register a comparator for

Parameters:

comparator - the Comparator to use to compare the given field

type - the type to be compared with the given comparator.

registerComparatorForField

public void registerComparatorForField(Comparator<?> comparator,
                                       FieldLocation fieldLocation)

Registers the given Comparator to compare the fields with the given locations.

The field locations must be specified from the root object, for example if Foo has a Bar field which has an id, one can register to a comparator for Bar's id by calling:

 registerComparatorForField(new FieldLocation("bar.id"), idComparator)

Comparators specified by this method have precedence over comparators added with registerComparatorForType(Comparator, Class).

See RecursiveComparisonAssert#withComparatorForFields(Comparator, String...) for examples.

Parameters:

comparator - the Comparator to use to compare the given field

fieldLocation - the location from the root object of the field the comparator should be used for

strictTypeChecking

public void strictTypeChecking(boolean strictTypeChecking)

Sets whether the recursive comparison will check that actual's type is compatible with expected's type (the same applies for each field). Compatible means that the expected's type is the same or a subclass of actual's type.

See RecursiveComparisonAssert.withStrictTypeChecking() for code examples.

Parameters:

strictTypeChecking - whether the recursive comparison will check that actual's type is compatible with expected's type.

isInStrictTypeCheckingMode

public boolean isInStrictTypeCheckingMode()

getIgnoredFieldsRegexes

public List<Pattern> getIgnoredFieldsRegexes()

getIgnoredOverriddenEqualsForTypes

public List<Class<?>> getIgnoredOverriddenEqualsForTypes()

getIgnoredOverriddenEqualsForFields

public List<FieldLocation> getIgnoredOverriddenEqualsForFields()

getIgnoredOverriddenEqualsRegexes

public List<Pattern> getIgnoredOverriddenEqualsRegexes()

comparatorByFields

public Stream<Map.Entry<FieldLocation,Comparator<?>>> comparatorByFields()

toString

public String toString()

Overrides:

toString in class Object

multiLineDescription

public String multiLineDescription(Representation representation)