Package org.assertj.core.api.recursive.comparison

Class RecursiveComparisonConfiguration

java.lang.Object
org.assertj.core.api.recursive.AbstractRecursiveOperationConfiguration
org.assertj.core.api.recursive.comparison.RecursiveComparisonConfiguration
public class RecursiveComparisonConfiguration extends org.assertj.core.api.recursive.AbstractRecursiveOperationConfiguration

  • Field Details

  • Constructor Details

    • RecursiveComparisonConfiguration

      public RecursiveComparisonConfiguration()

  • Method Details

    • 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()

    • 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

    • 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

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

    • compareOnlyFieldsOfTypes

      public void compareOnlyFieldsOfTypes(Class<?>... typesToCompare)
      Adds the given fields of types and their subfields to the set of fields from the object under test to compare (fields of other types will not be compared).

      Specifying a field of type will make all its subfields to be compared, for example specifying Person will lead to compare Person.name, Person.address ...

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

      Parameters:
      typesToCompare - the types to compare in the recursive comparison.

    • getComparedFields

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

    • getComparedTypes

      public Set<Class<?>> getComparedTypes()
      Returns the set of type to compare from the object under test (fields of other types will not be compared).
      Returns:
      the set of types from the object under test to compare.

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

    • 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 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

    • registerEqualsForFieldsMatchingRegexes

      public void registerEqualsForFieldsMatchingRegexes(BiPredicate<?,?> equals, String... regexes)
      Allows to register a BiPredicate to compare fields whose location matches the given regexes. A typical usage is to compare double/float fields with a given precision.

      The fields are evaluated 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: 

       registerEqualsForFieldsMatchingRegexes(idBiPredicate, ".*id")
      or 
       registerEqualsForFieldsMatchingRegexes(idBiPredicate, "foo.*id")

      BiPredicates registered with this method have precedence over the ones registered with registerEqualsForType(BiPredicate, Class) or the comparators registered with registerComparatorForType(Comparator, Class) but don't have precedence over the ones registered with exact location match: registerEqualsForFields(BiPredicate, String...) or registerComparatorForFields(Comparator, String...)

      If registered regexes for different BiPredicate match a given field, the latest registered regexes BiPredicate wins.

      Example: see RecursiveComparisonAssert.withEqualsForFieldsMatchingRegexes(BiPredicate, String...)

      Parameters:
      equals - the BiPredicate to use to compare the fields matching the given regexes
      regexes - the regexes from the root object of the fields location the BiPredicate should be used for
      Throws:
      NullPointerException - if the given BiPredicate is null.
      Since:
      3.24.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()

    • getIgnoredOverriddenEqualsForTypes

      public List<Class<?>> getIgnoredOverriddenEqualsForTypes()

    • getIgnoredOverriddenEqualsForFields

      public List<String> getIgnoredOverriddenEqualsForFields()

    • getIgnoredOverriddenEqualsForFieldsMatchingRegexes

      public List<Pattern> getIgnoredOverriddenEqualsForFieldsMatchingRegexes()

    • comparatorByFields

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

    • setIntrospectionStrategy

      public void setIntrospectionStrategy(RecursiveComparisonIntrospectionStrategy introspectionStrategy)
      Defines how objects are introspected in the recursive comparison.

      Default to DefaultRecursiveComparisonIntrospectionStrategy.

      Parameters:
      introspectionStrategy - the RecursiveComparisonIntrospectionStrategy to use

    • 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)

    • describeIgnoreAllActualNullFields

      protected void describeIgnoreAllActualNullFields(StringBuilder description)

    • describeIgnoreAllActualEmptyOptionalFields

      protected void describeIgnoreAllActualEmptyOptionalFields(StringBuilder description)

    • builder

      public static RecursiveComparisonConfiguration.Builder builder()
      Creates builder to build RecursiveComparisonConfiguration.
      Returns:
      created builder