java.lang.Object
- org.assertj.core.api.recursive.comparison.RecursiveComparisonConfiguration

public class RecursiveComparisonConfiguration
extends Object

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class RecursiveComparisonConfiguration.Builder
Builder to build RecursiveComparisonConfiguration.

Field Summary

Fields
Modifier and Type	Field	Description
`private Set<String>`	`comparedFields`
`private static String`	`DEFAULT_DELIMITER`
`private static boolean`	`DEFAULT_IGNORE_ALL_OVERRIDDEN_EQUALS`
`private FieldComparators`	`fieldComparators`
`private FieldMessages`	`fieldMessages`
`private boolean`	`ignoreAllActualEmptyOptionalFields`
`private boolean`	`ignoreAllActualNullFields`
`private boolean`	`ignoreAllExpectedNullFields`
`private boolean`	`ignoreAllOverriddenEquals`
`private boolean`	`ignoreCollectionOrder`
`private Set<String>`	`ignoredCollectionOrderInFields`
`private List<Pattern>`	`ignoredCollectionOrderInFieldsMatchingRegexes`
`private Set<String>`	`ignoredFields`
`private List<Pattern>`	`ignoredFieldsRegexes`
`private List<String>`	`ignoredOverriddenEqualsForFields`
`private List<Pattern>`	`ignoredOverriddenEqualsForFieldsMatchingRegexes`
`private List<Class<?>>`	`ignoredOverriddenEqualsForTypes`
`private Set<Class<?>>`	`ignoredTypes`
`static String`	`INDENT_LEVEL_2`
`private boolean`	`strictTypeChecking`
`private org.assertj.core.internal.TypeComparators`	`typeComparators`
`private org.assertj.core.internal.TypeMessages`	`typeMessages`

Constructor Summary

Constructors
Modifier Constructor Description

RecursiveComparisonConfiguration()

private RecursiveComparisonConfiguration(RecursiveComparisonConfiguration.Builder builder)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private static Class<?>`	`asWrapperIfPrimitiveType(Class<?> type)`
`static RecursiveComparisonConfiguration.Builder`	`builder()`	Creates builder to build `RecursiveComparisonConfiguration`.
`Stream<Map.Entry<String,Comparator<?>>>`	`comparatorByFields()`
`(package private) Stream<Map.Entry<Class<?>,Comparator<?>>>`	`comparatorByTypes()`
`void`	`compareOnlyFields(String... fieldNamesToCompare)`	Adds the given fields and their subfields to the set of fields from the object under test to compare (no other fields will be compared).
`private void`	`describeComparatorForFields(StringBuilder description)`
`private void`	`describeComparatorForTypes(StringBuilder description)`
`private String`	`describeComparedFields()`
`private void`	`describeComparedFields(StringBuilder description)`
`private void`	`describeErrorMessagesForFields(StringBuilder description)`
`private void`	`describeErrorMessagesForType(StringBuilder description)`
`private void`	`describeIgnoreAllActualEmptyOptionalFields(StringBuilder description)`
`private void`	`describeIgnoreAllActualNullFields(StringBuilder description)`
`private void`	`describeIgnoreAllExpectedNullFields(StringBuilder description)`
`private void`	`describeIgnoreCollectionOrder(StringBuilder description)`
`private String`	`describeIgnoredCollectionOrderInFields()`
`private void`	`describeIgnoredCollectionOrderInFields(StringBuilder description)`
`private void`	`describeIgnoredCollectionOrderInFieldsMatchingRegexes(StringBuilder description)`
`private String`	`describeIgnoredFields()`
`private void`	`describeIgnoredFields(StringBuilder description)`
`private void`	`describeIgnoredFieldsForTypes(StringBuilder description)`
`private void`	`describeIgnoredFieldsRegexes(StringBuilder description)`
`private String`	`describeIgnoredOverriddenEqualsForFields()`
`private String`	`describeIgnoredOverriddenEqualsForTypes(Representation representation)`
`private void`	`describeIgnoredOverriddenEqualsMethods(StringBuilder description, Representation representation)`
`private String`	`describeIgnoredTypes()`
`private void`	`describeOverriddenEqualsMethodsUsage(StringBuilder description, Representation representation)`
`private String`	`describeRegexes(List<Pattern> regexes)`
`private void`	`describeRegisteredComparatorByTypes(StringBuilder description)`
`private void`	`describeRegisteredComparatorForFields(StringBuilder description)`
`private void`	`describeRegisteredErrorMessagesForFields(StringBuilder description)`
`private void`	`describeRegisteredErrorMessagesForTypes(StringBuilder description)`
`private void`	`describeTypeCheckingStrictness(StringBuilder description)`
`private static DualValue`	`dualValueForField(DualValue parentDualValue, String fieldName)`
`boolean`	`equals(Object obj)`
`private String`	`formatRegisteredComparatorByType(Map.Entry<Class<?>,Comparator<?>> next)`
`private String`	`formatRegisteredComparatorForField(Map.Entry<String,Comparator<?>> comparatorForField)`
`Comparator<?>`	`getComparatorForField(String fieldName)`
`Comparator<?>`	`getComparatorForType(Class<?> fieldType)`
`Set<String>`	`getComparedFields()`	Returns the set of fields to compare from the object under test (no other fields will be compared).
`FieldComparators`	`getFieldComparators()`
`(package private) boolean`	`getIgnoreAllActualEmptyOptionalFields()`
`(package private) boolean`	`getIgnoreAllActualNullFields()`
`(package private) boolean`	`getIgnoreAllExpectedNullFields()`
`(package private) boolean`	`getIgnoreAllOverriddenEquals()`
`(package private) boolean`	`getIgnoreCollectionOrder()`
`Set<String>`	`getIgnoredCollectionOrderInFields()`	Returns the list fields from the object under test to ignore collection order in the recursive comparison.
`List<Pattern>`	`getIgnoredCollectionOrderInFieldsMatchingRegexes()`	Returns the list of regexes used to find the object under test fields to ignore collection order in the recursive comparison.
`Set<String>`	`getIgnoredFields()`	Returns the set of fields from the object under test to ignore in the recursive comparison.
`List<Pattern>`	`getIgnoredFieldsRegexes()`
`List<String>`	`getIgnoredOverriddenEqualsForFields()`
`List<Pattern>`	`getIgnoredOverriddenEqualsForFieldsMatchingRegexes()`
`List<Class<?>>`	`getIgnoredOverriddenEqualsForTypes()`
`Set<Class<?>>`	`getIgnoredTypes()`	Returns the set of fields from the object under test types to ignore in the recursive comparison.
`String`	`getMessageForField(String fieldName)`
`String`	`getMessageForType(Class<?> fieldType)`
`(package private) Set<String>`	`getNonIgnoredActualFieldNames(DualValue dualValue)`
`org.assertj.core.internal.TypeComparators`	`getTypeComparators()`
`boolean`	`hasComparatorForField(String fieldName)`
`boolean`	`hasComparatorForType(Class<?> keyType)`
`(package private) boolean`	`hasCustomComparator(DualValue dualValue)`
`boolean`	`hasCustomComparators()`
`boolean`	`hasCustomMessageForField(String fieldName)`
`boolean`	`hasCustomMessageForType(Class<?> fieldType)`
`int`	`hashCode()`
`void`	`ignoreAllOverriddenEquals()`	Force a recursive comparison on all fields (except java types).
`void`	`ignoreCollectionOrder(boolean ignoreCollectionOrder)`	Sets whether to ignore collection order in the comparison.
`void`	`ignoreCollectionOrderInFields(String... fieldsToIgnoreCollectionOrder)`	Adds the given fields to the list fields from the object under test to ignore collection order in the recursive comparison.
`void`	`ignoreCollectionOrderInFieldsMatchingRegexes(String... regexes)`	Adds the given regexes to the list of regexes used to find the object under test fields to ignore collection order in the recursive comparison.
`void`	`ignoreFields(String... fieldsToIgnore)`	Adds the given fields to the set of fields from the object under test 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`	`ignoreFieldsOfTypes(Class<?>... types)`	Adds the given types to the list fields from the object under test types to ignore in the recursive comparison.
`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.
`private boolean`	`isConfiguredToIgnoreSomeButNotAllOverriddenEqualsMethods()`
`boolean`	`isInStrictTypeCheckingMode()`
`private static String`	`join(Collection<String> typesDescription)`
`private boolean`	`matchesAnIgnoredCollectionOrderInField(FieldLocation fieldLocation)`
`private boolean`	`matchesAnIgnoredCollectionOrderInFieldRegex(FieldLocation fieldLocation)`
`private boolean`	`matchesAnIgnoredEmptyOptionalField(DualValue dualValue)`
`private boolean`	`matchesAnIgnoredField(FieldLocation fieldLocation)`
`private boolean`	`matchesAnIgnoredFieldRegex(FieldLocation fieldLocation)`
`private boolean`	`matchesAnIgnoredFieldType(DualValue dualValue)`
`private boolean`	`matchesAnIgnoredNullField(DualValue dualValue)`
`private boolean`	`matchesAnIgnoredOverriddenEqualsField(FieldLocation fieldLocation)`
`private boolean`	`matchesAnIgnoredOverriddenEqualsRegex(Class<?> clazz)`
`private boolean`	`matchesAnIgnoredOverriddenEqualsType(Class<?> clazz)`
`private static Predicate<String>`	`matchesComparedField(FieldLocation field)`
`String`	`multiLineDescription(Representation representation)`
`void`	`registerComparatorForFields(Comparator<?> comparator, String... fieldLocations)`	Registers the given `Comparator` to compare the fields at 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`	`registerEqualsForFields(BiPredicate<?,?> equals, String... fieldLocations)`	Registers the given `BiPredicate` to compare the fields at the given locations.
`<T> void`	`registerEqualsForType(BiPredicate<? super T,? super T> equals, Class<T> type)`	Registers the given `BiPredicate` to compare the fields with the given type.
`void`	`registerErrorMessageForFields(String message, String... fieldLocations)`	Registers the giving message which would be shown when differences in the given fields while comparison occurred.
`void`	`registerErrorMessageForType(String message, Class<?> clazz)`	Registers the giving message which would be shown when differences for the giving type while comparison occurred.
`void`	`setIgnoreAllActualEmptyOptionalFields(boolean ignoringAllActualEmptyOptionalFields)`	Sets whether actual empty optional fields are ignored in the recursive comparison.
`void`	`setIgnoreAllActualNullFields(boolean ignoreAllActualNullFields)`	Sets whether actual null fields are ignored in the recursive comparison.
`void`	`setIgnoreAllExpectedNullFields(boolean ignoreAllExpectedNullFields)`	Sets whether expected null fields are ignored in the recursive comparison.
`private boolean`	`shouldBeCompared(FieldLocation fieldLocation)`
`(package private) boolean`	`shouldIgnore(DualValue dualValue)`
`(package private) boolean`	`shouldIgnoreCollectionOrder(FieldLocation fieldLocation)`
`private boolean`	`shouldIgnoreFieldBasedOnFieldLocation(FieldLocation fieldLocation)`
`private boolean`	`shouldIgnoreFieldBasedOnFieldValue(DualValue dualValue)`
`(package private) boolean`	`shouldIgnoreOverriddenEqualsOf(Class<?> clazz)`
`(package private) boolean`	`shouldIgnoreOverriddenEqualsOf(DualValue dualValue)`
`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).
`private static Comparator`	`toComparator(BiPredicate equals)`
`String`	`toString()`
`void`	`useOverriddenEquals()`	Force a recursive comparison on all fields (except java types).

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - DEFAULT_DELIMITER
```
private static final String DEFAULT_DELIMITER
```
    See Also:
    
    Constant Field Values
  - DEFAULT_IGNORE_ALL_OVERRIDDEN_EQUALS
```
private static final boolean DEFAULT_IGNORE_ALL_OVERRIDDEN_EQUALS
```
    See Also:
    
    Constant Field Values
  - INDENT_LEVEL_2
```
public static final String INDENT_LEVEL_2
```
    See Also:
    
    Constant Field Values
  - strictTypeChecking
```
private boolean strictTypeChecking
```
  - ignoreAllActualNullFields
```
private boolean ignoreAllActualNullFields
```
  - ignoreAllActualEmptyOptionalFields
```
private boolean ignoreAllActualEmptyOptionalFields
```
  - ignoreAllExpectedNullFields
```
private boolean ignoreAllExpectedNullFields
```
  - ignoredFields
```
private Set<String> ignoredFields
```
  - ignoredFieldsRegexes
```
private List<Pattern> ignoredFieldsRegexes
```
  - ignoredTypes
```
private Set<Class<?>> ignoredTypes
```
  - comparedFields
```
private Set<String> comparedFields
```
  - ignoredOverriddenEqualsForTypes
```
private List<Class<?>> ignoredOverriddenEqualsForTypes
```
  - ignoredOverriddenEqualsForFields
```
private List<String> ignoredOverriddenEqualsForFields
```
  - ignoredOverriddenEqualsForFieldsMatchingRegexes
```
private List<Pattern> ignoredOverriddenEqualsForFieldsMatchingRegexes
```
  - ignoreAllOverriddenEquals
```
private boolean ignoreAllOverriddenEquals
```
  - ignoreCollectionOrder
```
private boolean ignoreCollectionOrder
```
  - ignoredCollectionOrderInFields
```
private Set<String> ignoredCollectionOrderInFields
```
  - ignoredCollectionOrderInFieldsMatchingRegexes
```
private List<Pattern> ignoredCollectionOrderInFieldsMatchingRegexes
```
  - typeComparators
```
private org.assertj.core.internal.TypeComparators typeComparators
```
  - fieldComparators
```
private FieldComparators fieldComparators
```
  - typeMessages
```
private org.assertj.core.internal.TypeMessages typeMessages
```
  - fieldMessages
```
private FieldMessages fieldMessages
```
- Constructor Detail
  - RecursiveComparisonConfiguration
```
private RecursiveComparisonConfiguration(RecursiveComparisonConfiguration.Builder builder)
```
  - RecursiveComparisonConfiguration
```
public RecursiveComparisonConfiguration()
```
- Method Detail
  - hasComparatorForField
```
public boolean hasComparatorForField(String fieldName)
```
  - getComparatorForField
```
public Comparator<?> getComparatorForField(String fieldName)
```
  - hasCustomMessageForField
```
public boolean hasCustomMessageForField(String fieldName)
```
  - getMessageForField
```
public String getMessageForField(String fieldName)
```
  - getFieldComparators
```
public FieldComparators getFieldComparators()
```
  - hasComparatorForType
```
public boolean hasComparatorForType(Class<?> keyType)
```
  - hasCustomComparators
```
public boolean hasCustomComparators()
```
  - getComparatorForType
```
public Comparator<?> getComparatorForType(Class<?> fieldType)
```
  - hasCustomMessageForType
```
public boolean hasCustomMessageForType(Class<?> fieldType)
```
  - getMessageForType
```
public String getMessageForType(Class<?> fieldType)
```
  - getTypeComparators
```
public org.assertj.core.internal.TypeComparators getTypeComparators()
```
  - comparatorByTypes
```
Stream<Map.Entry<Class<?>,Comparator<?>>> comparatorByTypes()
```
  - getIgnoreAllActualNullFields
```
boolean getIgnoreAllActualNullFields()
```
  - getIgnoreAllExpectedNullFields
```
boolean getIgnoreAllExpectedNullFields()
```
  - getIgnoreAllOverriddenEquals
```
boolean getIgnoreAllOverriddenEquals()
```
  - setIgnoreAllActualEmptyOptionalFields
```
public void setIgnoreAllActualEmptyOptionalFields(boolean ignoringAllActualEmptyOptionalFields)
```
    Sets whether actual empty optional fields are ignored in the recursive comparison.
    See RecursiveComparisonAssert.ignoringActualNullFields() for code examples.
    
    Parameters:
    
    ignoringAllActualEmptyOptionalFields - whether to ignore actual empty optional fields in the recursive comparison
  - getIgnoreAllActualEmptyOptionalFields
```
boolean getIgnoreAllActualEmptyOptionalFields()
```
  - 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 ignore actual null fields in the recursive comparison
  - setIgnoreAllExpectedNullFields
```
public void setIgnoreAllExpectedNullFields(boolean ignoreAllExpectedNullFields)
```
    Sets whether expected null fields are ignored in the recursive comparison.
    See RecursiveComparisonAssert.ignoringExpectedNullFields() for code examples.
    
    Parameters:
    
    ignoreAllExpectedNullFields - whether to ignore expected null fields in the recursive comparison
  - ignoreFields
```
public void ignoreFields(String... fieldsToIgnore)
```
    Adds the given fields to the set of fields from the object under test to ignore in the recursive comparison.
    The fields are ignored by name, not by value.
    See RecursiveComparisonAssert#ignoringFields(String...) for examples.
    
    Parameters:
    
    fieldsToIgnore - the fields of the object under test to ignore in the comparison.
  - compareOnlyFields
```
public void compareOnlyFields(String... fieldNamesToCompare)
```
    Adds the given fields and their subfields to the set of fields from the object under test to compare (no other fields will be compared).
    The fields are specified by name, not by value, you can specify person.name but not "Jack" as "Jack" is not a field value.
    Specifying a field will make all its subfields to be compared, for example specifying person will lead to compare person.name, person.address ... on the other hand if you specify person.name, person won't be compared but person.name will be.
    See RecursiveComparisonAssert#comparingOnlyFields(String...) for examples.
    
    Parameters:
    
    fieldNamesToCompare - the fields of the object under test to compare 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.
  - ignoreFieldsOfTypes
```
public void ignoreFieldsOfTypes(Class<?>... types)
```
    Adds the given types to the list fields from the object under test types to ignore in the recursive comparison. The fields are ignored if their types exactly match one of the ignored types, if a field is a subtype of an ignored type it won't be ignored.
    Note that if some object under test fields are null, they are not ignored by this method as their type can't be evaluated.
    See RecursiveComparisonAssert#ignoringFieldsOfTypes(Class...) for examples.
    
    Parameters:
    
    types - the types of the object under test to ignore in the comparison.
  - asWrapperIfPrimitiveType
```
private static Class<?> asWrapperIfPrimitiveType(Class<?> type)
```
  - getIgnoredFields
```
public Set<String> getIgnoredFields()
```
    Returns the set of fields from the object under test to ignore in the recursive comparison.
    
    Returns:
    
    the set of fields from the object under test to ignore in the recursive comparison.
  - getComparedFields
```
public Set<String> getComparedFields()
```
    Returns the set of fields to compare from the object under test (no other fields will be compared).
    
    Returns:
    
    the set of fields from the object under test to compare.
  - getIgnoredTypes
```
public Set<Class<?>> getIgnoredTypes()
```
    Returns the set of fields from the object under test types to ignore in the recursive comparison.
    
    Returns:
    
    the set of fields from the object under test types 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.
  - useOverriddenEquals
```
public void useOverriddenEquals()
```
    Force a recursive comparison on all fields (except java types).
    See RecursiveComparisonAssert.usingOverriddenEquals() 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.
  - getIgnoreCollectionOrder
```
boolean getIgnoreCollectionOrder()
```
  - ignoreCollectionOrder
```
public void ignoreCollectionOrder(boolean ignoreCollectionOrder)
```
    Sets whether to ignore collection order in the comparison.
    See RecursiveComparisonAssert.ignoringCollectionOrder() for code examples.
    
    Parameters:
    
    ignoreCollectionOrder - whether to ignore collection order in the comparison.
  - ignoreCollectionOrderInFields
```
public void ignoreCollectionOrderInFields(String... fieldsToIgnoreCollectionOrder)
```
    Adds the given fields to the list fields from the object under test to ignore collection order in the recursive comparison.
    See RecursiveComparisonAssert#ignoringCollectionOrderInFields(String...) for examples.
    
    Parameters:
    
    fieldsToIgnoreCollectionOrder - the fields of the object under test to ignore collection order in the comparison.
  - getIgnoredCollectionOrderInFields
```
public Set<String> getIgnoredCollectionOrderInFields()
```
    Returns the list fields from the object under test to ignore collection order in the recursive comparison.
    
    Returns:
    
    the list fields from the object under test to ignore collection order in the recursive comparison.
  - ignoreCollectionOrderInFieldsMatchingRegexes
```
public void ignoreCollectionOrderInFieldsMatchingRegexes(String... regexes)
```
    Adds the given regexes to the list of regexes used to find the object under test fields to ignore collection order in the recursive comparison.
    See RecursiveComparisonAssert#ignoringCollectionOrderInFieldsMatchingRegexes(String...) for examples.
    
    Parameters:
    
    regexes - regexes used to find the object under test fields to ignore collection order in in the comparison.
  - getIgnoredCollectionOrderInFieldsMatchingRegexes
```
public List<Pattern> getIgnoredCollectionOrderInFieldsMatchingRegexes()
```
    Returns the list of regexes used to find the object under test fields to ignore collection order in the recursive comparison.
    
    Returns:
    
    the list of regexes used to find the object under test fields to ignore collection order in the recursive comparison.
  - 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 registered with this method have less precedence than comparators registered with registerComparatorForFields(Comparator, String...).
    Note that registering a Comparator for a given type will override the previously registered BiPredicate/Comparator (if any).
    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 type
    
    type - the type to be compared with the given comparator.
    
    Throws:
    
    NullPointerException - if the given comparator is null.
  - registerEqualsForType
```
public <T> void registerEqualsForType(BiPredicate<? super T,? super T> equals,
                                      Class<T> type)
```
    Registers the given BiPredicate to compare the fields with the given type.
    BiPredicates specified with this method have less precedence than the ones registered with registerEqualsForFields(BiPredicate, String...) or comparators registered with registerComparatorForFields(Comparator, String...).
    Note that registering a BiPredicate for a given type will override the previously registered BiPredicate/Comparator (if any).
    See RecursiveComparisonAssert.withEqualsForType(BiPredicate, Class) for examples.
    
    Type Parameters:
    
    T - the class type to register a comparator for
    
    Parameters:
    
    equals - the equals implementation to compare the given type
    
    type - the type to be compared with the given equals implementation .
    
    Throws:
    
    NullPointerException - if the given BiPredicate is null.
    
    Since:
    
    3.17.0
  - registerComparatorForFields
```
public void registerComparatorForFields(Comparator<?> comparator,
                                        String... fieldLocations)
```
    Registers the given Comparator to compare the fields at the given locations.
    The fields must be specified from the root object, for example if Foo has a Bar field and both have an id field, one can register a comparator for Foo and Bar's id by calling:
    registerComparatorForFields(idComparator, "foo.id", "foo.bar.id")
    
    Comparators registered with this method have precedence over comparators registered with registerComparatorForType(Comparator, Class).
    Note that registering a Comparator for a given field will override the previously registered BiPredicate/Comparator (if any).
    See RecursiveComparisonAssert#withComparatorForFields(Comparator, String...) for examples.
    Parameters:
    
    comparator - the Comparator to use to compare the given field
    
    fieldLocations - the locations from the root object of the fields the comparator should be used for
    
    Throws:
    
    NullPointerException - if the given comparator is null.
  - registerEqualsForFields
```
public void registerEqualsForFields(BiPredicate<?,?> equals,
                                    String... fieldLocations)
```
    Registers the given BiPredicate to compare the fields at the given locations.
    The fields must be specified from the root object, for example if Foo has a Bar field and both have an id field, one can register a BiPredicate for Foo and Bar's id by calling:
    registerEqualsForFields(idBiPredicate, "foo.id", "foo.bar.id")
    
    BiPredicates registered with this method have precedence over the ones registered with registerEqualsForType(BiPredicate, Class) or the comparators registered with registerComparatorForType(Comparator, Class).
    Note that registering a BiPredicate for a given field will override the previously registered BiPredicate/Comparator (if any).
    See RecursiveComparisonAssert#withEqualsForFields(BiPredicate, String...) for examples.
    Parameters:
    
    equals - the equals implementation to compare the given fields.
    
    fieldLocations - the locations from the root object of the fields the comparator should be used for
    
    Throws:
    
    NullPointerException - if the given BiPredicate is null.
    
    Since:
    
    3.17.0
  - registerErrorMessageForFields
```
public void registerErrorMessageForFields(String message,
                                          String... fieldLocations)
```
    Registers the giving message which would be shown when differences in the given fields while comparison occurred.
    The fields must be specified from the root object, for example if Foo has a Bar field and both have an id field, one can register a message for Foo and Bar's id by calling:
    registerErrorMessageForFields("some message", "foo.id", "foo.bar.id")
    
    Messages registered with this method have precedence over the ones registered with registerErrorMessageForType(String, Class).
    In case of null as message the default error message will be used (See ComparisonDifference.DEFAULT_TEMPLATE).
    Parameters:
    
    message - the error message that will be thrown when comparison error occurred
    
    fieldLocations - the field locations the error message should be used for
  - registerErrorMessageForType
```
public void registerErrorMessageForType(String message,
                                        Class<?> clazz)
```
    Registers the giving message which would be shown when differences for the giving type while comparison occurred.
    Message registered with this method have less precedence than the ones registered with registerErrorMessageForFields(String, String...).
    In case of null as message the default error message will be used (See ComparisonDifference.DEFAULT_TEMPLATE).
    
    Parameters:
    
    message - the error message that will be thrown when comparison error occurred
    
    clazz - the type the error message 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<String> getIgnoredOverriddenEqualsForFields()
```
  - getIgnoredOverriddenEqualsForFieldsMatchingRegexes
```
public List<Pattern> getIgnoredOverriddenEqualsForFieldsMatchingRegexes()
```
  - comparatorByFields
```
public Stream<Map.Entry<String,Comparator<?>>> comparatorByFields()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - multiLineDescription
```
public String multiLineDescription(Representation representation)
```
  - shouldIgnore
```
boolean shouldIgnore(DualValue dualValue)
```
  - shouldBeCompared
```
private boolean shouldBeCompared(FieldLocation fieldLocation)
```
  - matchesComparedField
```
private static Predicate<String> matchesComparedField(FieldLocation field)
```
  - getNonIgnoredActualFieldNames
```
Set<String> getNonIgnoredActualFieldNames(DualValue dualValue)
```
  - shouldIgnoreFieldBasedOnFieldValue
```
private boolean shouldIgnoreFieldBasedOnFieldValue(DualValue dualValue)
```
  - shouldIgnoreFieldBasedOnFieldLocation
```
private boolean shouldIgnoreFieldBasedOnFieldLocation(FieldLocation fieldLocation)
```
  - dualValueForField
```
private static DualValue dualValueForField(DualValue parentDualValue,
                                           String fieldName)
```
  - hasCustomComparator
```
boolean hasCustomComparator(DualValue dualValue)
```
  - shouldIgnoreOverriddenEqualsOf
```
boolean shouldIgnoreOverriddenEqualsOf(DualValue dualValue)
```
  - shouldIgnoreOverriddenEqualsOf
```
boolean shouldIgnoreOverriddenEqualsOf(Class<?> clazz)
```
  - shouldIgnoreCollectionOrder
```
boolean shouldIgnoreCollectionOrder(FieldLocation fieldLocation)
```
  - describeIgnoredFieldsRegexes
```
private void describeIgnoredFieldsRegexes(StringBuilder description)
```
  - describeIgnoredFields
```
private void describeIgnoredFields(StringBuilder description)
```
  - describeComparedFields
```
private void describeComparedFields(StringBuilder description)
```
  - describeIgnoredFieldsForTypes
```
private void describeIgnoredFieldsForTypes(StringBuilder description)
```
  - describeIgnoreAllActualNullFields
```
private void describeIgnoreAllActualNullFields(StringBuilder description)
```
  - describeIgnoreAllActualEmptyOptionalFields
```
private void describeIgnoreAllActualEmptyOptionalFields(StringBuilder description)
```
  - describeIgnoreAllExpectedNullFields
```
private void describeIgnoreAllExpectedNullFields(StringBuilder description)
```
  - describeOverriddenEqualsMethodsUsage
```
private void describeOverriddenEqualsMethodsUsage(StringBuilder description,
                                                  Representation representation)
```
  - describeIgnoredOverriddenEqualsMethods
```
private void describeIgnoredOverriddenEqualsMethods(StringBuilder description,
                                                    Representation representation)
```
  - describeIgnoredOverriddenEqualsForTypes
```
private String describeIgnoredOverriddenEqualsForTypes(Representation representation)
```
  - describeIgnoredOverriddenEqualsForFields
```
private String describeIgnoredOverriddenEqualsForFields()
```
  - describeIgnoreCollectionOrder
```
private void describeIgnoreCollectionOrder(StringBuilder description)
```
  - describeIgnoredCollectionOrderInFields
```
private void describeIgnoredCollectionOrderInFields(StringBuilder description)
```
  - describeIgnoredCollectionOrderInFieldsMatchingRegexes
```
private void describeIgnoredCollectionOrderInFieldsMatchingRegexes(StringBuilder description)
```
  - matchesAnIgnoredOverriddenEqualsRegex
```
private boolean matchesAnIgnoredOverriddenEqualsRegex(Class<?> clazz)
```
  - matchesAnIgnoredOverriddenEqualsType
```
private boolean matchesAnIgnoredOverriddenEqualsType(Class<?> clazz)
```
  - matchesAnIgnoredOverriddenEqualsField
```
private boolean matchesAnIgnoredOverriddenEqualsField(FieldLocation fieldLocation)
```
  - matchesAnIgnoredNullField
```
private boolean matchesAnIgnoredNullField(DualValue dualValue)
```
  - matchesAnIgnoredEmptyOptionalField
```
private boolean matchesAnIgnoredEmptyOptionalField(DualValue dualValue)
```
  - matchesAnIgnoredFieldRegex
```
private boolean matchesAnIgnoredFieldRegex(FieldLocation fieldLocation)
```
  - matchesAnIgnoredFieldType
```
private boolean matchesAnIgnoredFieldType(DualValue dualValue)
```
  - matchesAnIgnoredField
```
private boolean matchesAnIgnoredField(FieldLocation fieldLocation)
```
  - matchesAnIgnoredCollectionOrderInField
```
private boolean matchesAnIgnoredCollectionOrderInField(FieldLocation fieldLocation)
```
  - matchesAnIgnoredCollectionOrderInFieldRegex
```
private boolean matchesAnIgnoredCollectionOrderInFieldRegex(FieldLocation fieldLocation)
```
  - describeIgnoredFields
```
private String describeIgnoredFields()
```
  - describeComparedFields
```
private String describeComparedFields()
```
  - describeIgnoredTypes
```
private String describeIgnoredTypes()
```
  - join
```
private static String join(Collection<String> typesDescription)
```
  - describeIgnoredCollectionOrderInFields
```
private String describeIgnoredCollectionOrderInFields()
```
  - describeRegexes
```
private String describeRegexes(List<Pattern> regexes)
```
  - isConfiguredToIgnoreSomeButNotAllOverriddenEqualsMethods
```
private boolean isConfiguredToIgnoreSomeButNotAllOverriddenEqualsMethods()
```
  - describeRegisteredComparatorByTypes
```
private void describeRegisteredComparatorByTypes(StringBuilder description)
```
  - describeComparatorForTypes
```
private void describeComparatorForTypes(StringBuilder description)
```
  - formatRegisteredComparatorByType
```
private String formatRegisteredComparatorByType(Map.Entry<Class<?>,Comparator<?>> next)
```
  - describeRegisteredComparatorForFields
```
private void describeRegisteredComparatorForFields(StringBuilder description)
```
  - describeComparatorForFields
```
private void describeComparatorForFields(StringBuilder description)
```
  - formatRegisteredComparatorForField
```
private String formatRegisteredComparatorForField(Map.Entry<String,Comparator<?>> comparatorForField)
```
  - describeTypeCheckingStrictness
```
private void describeTypeCheckingStrictness(StringBuilder description)
```
  - describeRegisteredErrorMessagesForFields
```
private void describeRegisteredErrorMessagesForFields(StringBuilder description)
```
  - describeErrorMessagesForFields
```
private void describeErrorMessagesForFields(StringBuilder description)
```
  - describeRegisteredErrorMessagesForTypes
```
private void describeRegisteredErrorMessagesForTypes(StringBuilder description)
```
  - describeErrorMessagesForType
```
private void describeErrorMessagesForType(StringBuilder description)
```
  - builder
```
public static RecursiveComparisonConfiguration.Builder builder()
```
    Creates builder to build RecursiveComparisonConfiguration.
    
    Returns:
    
    created builder
  - toComparator
```
private static Comparator toComparator(BiPredicate equals)
```

Modifier	Constructor	Description
	`RecursiveComparisonConfiguration()`
`private`	`RecursiveComparisonConfiguration(RecursiveComparisonConfiguration.Builder builder)`

Class RecursiveComparisonConfiguration

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_DELIMITER

DEFAULT_IGNORE_ALL_OVERRIDDEN_EQUALS

INDENT_LEVEL_2

strictTypeChecking

ignoreAllActualNullFields

ignoreAllActualEmptyOptionalFields

ignoreAllExpectedNullFields

ignoredFields

ignoredFieldsRegexes

ignoredTypes

comparedFields

ignoredOverriddenEqualsForTypes

ignoredOverriddenEqualsForFields

ignoredOverriddenEqualsForFieldsMatchingRegexes

ignoreAllOverriddenEquals

ignoreCollectionOrder

ignoredCollectionOrderInFields

ignoredCollectionOrderInFieldsMatchingRegexes

typeComparators

fieldComparators

typeMessages

fieldMessages

Constructor Detail

RecursiveComparisonConfiguration

RecursiveComparisonConfiguration

Method Detail

hasComparatorForField

getComparatorForField

hasCustomMessageForField

getMessageForField

getFieldComparators

hasComparatorForType

hasCustomComparators

getComparatorForType

hasCustomMessageForType

getMessageForType

getTypeComparators

comparatorByTypes

getIgnoreAllActualNullFields

getIgnoreAllExpectedNullFields

getIgnoreAllOverriddenEquals

setIgnoreAllActualEmptyOptionalFields

getIgnoreAllActualEmptyOptionalFields

setIgnoreAllActualNullFields

setIgnoreAllExpectedNullFields

ignoreFields

compareOnlyFields

ignoreFieldsMatchingRegexes

ignoreFieldsOfTypes

asWrapperIfPrimitiveType

getIgnoredFields

getComparedFields

getIgnoredTypes

ignoreAllOverriddenEquals

useOverriddenEquals

ignoreOverriddenEqualsForFields

ignoreOverriddenEqualsForFieldsMatchingRegexes

ignoreOverriddenEqualsForTypes

getIgnoreCollectionOrder

ignoreCollectionOrder

ignoreCollectionOrderInFields

getIgnoredCollectionOrderInFields

ignoreCollectionOrderInFieldsMatchingRegexes

getIgnoredCollectionOrderInFieldsMatchingRegexes

registerComparatorForType

registerEqualsForType

registerComparatorForFields

registerEqualsForFields

registerErrorMessageForFields

registerErrorMessageForType

strictTypeChecking

isInStrictTypeCheckingMode

getIgnoredFieldsRegexes