How to use AbstractRecursiveOperationConfiguration method of org.assertj.core.api.recursive.AbstractRecursiveOperationConfiguration class

Best Assertj code snippet using org.assertj.core.api.recursive.AbstractRecursiveOperationConfiguration.AbstractRecursiveOperationConfiguration

Source:RecursiveComparisonConfiguration.java

...31import java.util.function.Predicate;32import java.util.regex.Pattern;33import java.util.stream.Stream;34import org.assertj.core.api.RecursiveComparisonAssert;35import org.assertj.core.api.recursive.AbstractRecursiveOperationConfiguration;36import org.assertj.core.internal.Objects;37import org.assertj.core.internal.TypeComparators;38import org.assertj.core.internal.TypeMessages;39import org.assertj.core.presentation.Representation;40import org.assertj.core.util.VisibleForTesting;41public class RecursiveComparisonConfiguration extends AbstractRecursiveOperationConfiguration {42  private static final boolean DEFAULT_IGNORE_ALL_OVERRIDDEN_EQUALS = true;43  public static final String INDENT_LEVEL_2 = "  -";44  private boolean strictTypeChecking = false;45  // fields to ignore section46  private boolean ignoreAllActualNullFields = false;47  private boolean ignoreAllActualEmptyOptionalFields = false;48  private boolean ignoreAllExpectedNullFields = false;49  // fields to compare (no other field will be)50  private Set<FieldLocation> comparedFields = new LinkedHashSet<>();51  // overridden equals method to ignore section52  private final List<Class<?>> ignoredOverriddenEqualsForTypes = new ArrayList<>();53  private List<String> ignoredOverriddenEqualsForFields = new ArrayList<>();54  private final List<Pattern> ignoredOverriddenEqualsForFieldsMatchingRegexes = new ArrayList<>();55  private boolean ignoreAllOverriddenEquals = DEFAULT_IGNORE_ALL_OVERRIDDEN_EQUALS;...

Source:RecursiveAssertionConfiguration.java

...19import java.util.Collection;20import java.util.Objects;21import java.util.function.Predicate;22import org.assertj.core.api.RecursiveAssertionAssert;23import org.assertj.core.api.recursive.AbstractRecursiveOperationConfiguration;24// Add support for comparedFields25/**26 * Configuration for recursive assertions.27 *28 * @since 3.24.029 */30public class RecursiveAssertionConfiguration extends AbstractRecursiveOperationConfiguration {31  private boolean ignorePrimitiveFields;32  private final boolean skipJavaLibraryTypeObjects;33  private CollectionAssertionPolicy collectionAssertionPolicy;34  private MapAssertionPolicy mapAssertionPolicy;35  private OptionalAssertionPolicy optionalAssertionPolicy;36  private boolean ignoreAllNullFields;37  private RecursiveAssertionIntrospectionStrategy introspectionStrategy;38  private RecursiveAssertionConfiguration(Builder builder) {39    super(builder);40    this.ignorePrimitiveFields = builder.ignorePrimitiveFields;41    this.skipJavaLibraryTypeObjects = builder.skipJavaLibraryTypeObjects;42    this.collectionAssertionPolicy = builder.collectionAssertionPolicy;43    this.mapAssertionPolicy = builder.mapAssertionPolicy;44    this.optionalAssertionPolicy = builder.optionalAssertionPolicy;...

Source:AbstractRecursiveOperationConfiguration.java

...24import java.util.stream.Stream;25import org.assertj.core.api.RecursiveComparisonAssert;26import org.assertj.core.api.recursive.comparison.FieldLocation;27import org.assertj.core.util.Strings;28public abstract class AbstractRecursiveOperationConfiguration {29  protected static final String DEFAULT_DELIMITER = ", ";30  private final Set<String> ignoredFields = new LinkedHashSet<>();31  private final List<Pattern> ignoredFieldsRegexes = new ArrayList<>();32  private final Set<Class<?>> ignoredTypes = new LinkedHashSet<>();33  protected AbstractRecursiveOperationConfiguration(AbstractBuilder<?> builder) {34    ignoreFields(builder.ignoredFields);35    ignoreFieldsMatchingRegexes(builder.ignoredFieldsMatchingRegexes);36    ignoreFieldsOfTypes(builder.ignoredTypes);37  }38  protected AbstractRecursiveOperationConfiguration() {39  }40  /**41   * Adds the given fields to the set of fields from the object under test to ignore in the recursive comparison.42   * <p>43   * The fields are ignored by name, not by value.44   * <p>45   * See {@link RecursiveComparisonAssert#ignoringFields(String...) RecursiveComparisonAssert#ignoringFields(String...)} for examples.46   *47   * @param fieldsToIgnore the fields of the object under test to ignore in the comparison.48   */49  public void ignoreFields(String... fieldsToIgnore) {50    List<String> fieldLocations = list(fieldsToIgnore);51    ignoredFields.addAll(fieldLocations);52  }53  /**54   * Returns the set of fields from the object under test to ignore in the recursive comparison.55   *56   * @return the set of fields from the object under test to ignore in the recursive comparison.57   */58  public Set<String> getIgnoredFields() {59    return ignoredFields;60  }61  /**62   * 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.63   * <p>64   * See {@link RecursiveComparisonAssert#ignoringFieldsMatchingRegexes(String...) RecursiveComparisonAssert#ignoringFieldsMatchingRegexes(String...)} for examples.65   *66   * @param regexes regexes used to ignore fields in the comparison.67   */68  public void ignoreFieldsMatchingRegexes(String... regexes) {69    List<Pattern> patterns = Stream.of(regexes)70                                   .map(Pattern::compile)71                                   .collect(toList());72    ignoredFieldsRegexes.addAll(patterns);73  }74  public List<Pattern> getIgnoredFieldsRegexes() {75    return ignoredFieldsRegexes;76  }77  /**78   * Makes the recursive assertion to ignore the object under test fields of the given types.79   * The fields are ignored if their types <b>exactly match one of the ignored types</b>, for example if a field is a subtype of an ignored type it is not ignored.80   * <p>81   * If some object under test fields are null it is not possible to evaluate their types and thus these fields are not ignored.82   * <p>83   * Example:84   * <pre><code class='java'> public class Person {85   *   String name;86   *   String occupation;87   *   Address address = new Address();88   * }89   *90   * public static class Address {91   *   int number;92   *   String street;93   * }94   *95   * Person sherlock = new Person("Sherlock", "Detective");96   * sherlock.address.street = "Baker Street";97   * sherlock.address.number = 221;98   *99   * // assertion succeeds Person has only String fields except for address100   * assertThat(sherlock).usingRecursiveAssertion()101   *                     .ignoringFieldsOfTypes(Address.class)102   *                     .allFieldsSatisfy(field -> field instanceof String);103   *104   * // assertion fails because of address and address.number105   * assertThat(sherlock).usingRecursiveComparison()106   *                     .allFieldsSatisfy(field -> field instanceof String);</code></pre>107   *108   * @param types the types of the object under test to ignore in the comparison.109   */110  public void ignoreFieldsOfTypes(Class<?>... types) {111    stream(types).map(AbstractRecursiveOperationConfiguration::asWrapperIfPrimitiveType).forEach(ignoredTypes::add);112  }113  private static Class<?> asWrapperIfPrimitiveType(Class<?> type) {114    if (!type.isPrimitive()) return type;115    if (type.equals(boolean.class)) return Boolean.class;116    if (type.equals(byte.class)) return Byte.class;117    if (type.equals(int.class)) return Integer.class;118    if (type.equals(short.class)) return Short.class;119    if (type.equals(char.class)) return Character.class;120    if (type.equals(float.class)) return Float.class;121    if (type.equals(double.class)) return Double.class;122    // should not arrive here since we have tested primitive types first123    return type;124  }125  /**...