Add RecursiveComparisonAssert fluent API Tests

src/main/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonAssert.java

@@ -128,4 +128,9 @@ public final RecursiveComparisonAssert withComparatorForTypes(Map.Entry<Class<?>
           .forEach(comparatorByType -> withComparatorForType(comparatorByType.getKey(), comparatorByType.getValue()));
     return this;
   }
+
+  @VisibleForTesting
+  RecursiveComparisonConfiguration getRecursiveComparisonConfiguration() {
+    return recursiveComparisonConfiguration;
+  }
 }

src/main/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonConfiguration.java

@@ -54,7 +54,6 @@ public class RecursiveComparisonConfiguration {
   private TypeComparators typeComparators = defaultTypeComparators();
   private FieldComparators fieldComparators = new FieldComparators();
 
-  // TODO use FieldLocation instead of String ?
   public boolean hasComparatorForField(String fieldName) {
     return fieldComparators.hasComparatorForField(new FieldLocation(fieldName));
   }
@@ -80,6 +79,11 @@ TypeComparators getTypeComparators() {
     return typeComparators;
   }
 
+  @VisibleForTesting
+  boolean getIgnoreAllActualNullFields() {
+    return ignoreAllActualNullFields;
+  }
+
   /**
    * Sets whether actual null fields are ignored in the recursive comparison.
    * <p>
@@ -143,14 +147,34 @@ public void registerComparatorForField(FieldLocation fieldLocation, Comparator<?
     this.fieldComparators.registerComparator(fieldLocation, comparator);
   }
 
-  public boolean enforceStrictTypeChecking() {
+  public boolean isInStrictTypeCheckingMode() {
     return strictTypeChecking;
   }
 
   public void strictTypeChecking(boolean strictTypeChecking) {
     this.strictTypeChecking = strictTypeChecking;
   }
 
+  public List<Pattern> getIgnoredFieldsRegexes() {
+    return ignoredFieldsRegexes;
+  }
+
+  public List<Class<?>> getIgnoredOverriddenEqualsForTypes() {
+    return ignoredOverriddenEqualsForTypes;
+  }
+
+  public List<FieldLocation> getIgnoredOverriddenEqualsForFields() {
+    return ignoredOverriddenEqualsForFields;
+  }
+
+  public List<Pattern> getIgnoredOverriddenEqualsRegexes() {
+    return ignoredOverriddenEqualsRegexes;
+  }
+
+  public FieldComparators getFieldComparators() {
+    return fieldComparators;
+  }
+
   @Override
   public String toString() {
     return multiLineDescription(CONFIGURATION_PROVIDER.representation());

src/main/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonDifferenceCalculator.java

@@ -76,7 +76,7 @@ public class RecursiveComparisonDifferenceCalculator {
    */
   public List<ComparisonDifference> determineDifferences(Object actual, Object expected,
                                                          RecursiveComparisonConfiguration recursiveComparisonConfiguration) {
-    if (recursiveComparisonConfiguration.enforceStrictTypeChecking() && expectedTypeIsNotSubtypeOfActualType(actual, expected)) {
+    if (recursiveComparisonConfiguration.isInStrictTypeCheckingMode() && expectedTypeIsNotSubtypeOfActualType(actual, expected)) {
       return list(expectedAndActualTypeDifference(actual, expected));
     }
     return determineDifferences(actual, expected, null, recursiveComparisonConfiguration);
@@ -229,7 +229,7 @@ && hasCustomEquals(actualFieldClass)) {
       }
 
       Class<?> expectedFieldClass = key2.getClass();
-      if (recursiveComparisonConfiguration.enforceStrictTypeChecking() && expectedTypeIsNotSubtypeOfActualType(dualKey)) {
+      if (recursiveComparisonConfiguration.isInStrictTypeCheckingMode() && expectedTypeIsNotSubtypeOfActualType(dualKey)) {
         differences.add(new ComparisonDifference(currentPath, key1, key2,
                                                  format("the fields are considered different since the comparison enforces strict type check and %s is not a subtype of %s",
                                                         expectedFieldClass.getName(), actualFieldClass.getName())));

src/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonAssert_fluent_API_Test.java

@@ -0,0 +1,87 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2018 the original author or authors.
+ */
+package org.assertj.core.api.recursive.comparison;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.test.AlwaysDifferentComparator.alwaysDifferent;
+import static org.assertj.core.test.AlwaysEqualComparator.alwaysEqual;
+
+import org.assertj.core.internal.TypeComparators;
+import org.assertj.core.test.AlwaysDifferentComparator;
+import org.assertj.core.test.AlwaysEqualComparator;
+import org.junit.jupiter.api.Test;
+
+public class RecursiveComparisonAssert_fluent_API_Test {
+
+  private final static Object ACTUAL = "";
+
+  @Test
+  public void usingRecursiveComparison_should_set_a_default_RecursiveComparisonConfiguration() {
+    // WHEN
+    RecursiveComparisonConfiguration recursiveComparisonConfiguration = assertThat(ACTUAL).usingRecursiveComparison()
+                                                                                          .getRecursiveComparisonConfiguration();
+    // THEN
+    assertThat(recursiveComparisonConfiguration.isInStrictTypeCheckingMode()).isFalse();
+    assertThat(recursiveComparisonConfiguration.getTypeComparators()).isEqualTo(TypeComparators.defaultTypeComparators());
+    assertThat(recursiveComparisonConfiguration.getFieldComparators().isEmpty()).isTrue();
+    assertThat(recursiveComparisonConfiguration.getIgnoreAllActualNullFields()).isFalse();
+    assertThat(recursiveComparisonConfiguration.getIgnoredFields()).isEmpty();
+    assertThat(recursiveComparisonConfiguration.getIgnoredFieldsRegexes()).isEmpty();
+    assertThat(recursiveComparisonConfiguration.getIgnoredOverriddenEqualsForFields()).isEmpty();
+    assertThat(recursiveComparisonConfiguration.getIgnoredOverriddenEqualsForTypes()).isEmpty();
+    assertThat(recursiveComparisonConfiguration.getIgnoredOverriddenEqualsRegexes()).isEmpty();
+    // TODO assertThat(recursiveComparisonConfiguration.hasNoCustomComparators()).isTrue();
+  }
+
+  @Test
+  public void should_allow_to_use_its_own_RecursiveComparisonConfiguration() {
+    // GIVEN
+    RecursiveComparisonConfiguration recursiveComparisonConfiguration = new RecursiveComparisonConfiguration();
+    // WHEN
+    RecursiveComparisonConfiguration configuration = assertThat(ACTUAL).usingRecursiveComparison(recursiveComparisonConfiguration)
+                                                                       .getRecursiveComparisonConfiguration();
+    // THEN
+    assertThat(configuration).isSameAs(recursiveComparisonConfiguration);
+  }
+
+  @Test
+  public void should_allow_to_override_field_comparator() {
+    // GIVEN
+    String field = "foo.bar";
+    AlwaysEqualComparator<Object> alwaysEqualComparator = alwaysEqual();
+    AlwaysDifferentComparator<Object> alwaysDifferentComparator = alwaysDifferent();
+    // WHEN
+    RecursiveComparisonConfiguration configuration = assertThat(ACTUAL).usingRecursiveComparison()
+                                                                       .withComparatorForField(field, alwaysEqualComparator)
+                                                                       .withComparatorForField(field, alwaysDifferentComparator)
+                                                                       .getRecursiveComparisonConfiguration();
+    // THEN
+    assertThat(configuration.getComparatorForField(field)).isSameAs(alwaysDifferentComparator);
+  }
+
+  @Test
+  public void should_allow_to_override_type_comparator() {
+    // GIVEN
+    Class<?> type = String.class;
+    AlwaysEqualComparator<Object> alwaysEqualComparator = alwaysEqual();
+    AlwaysDifferentComparator<Object> alwaysDifferentComparator = alwaysDifferent();
+    // WHEN
+    RecursiveComparisonConfiguration configuration = assertThat(ACTUAL).usingRecursiveComparison()
+                                                                       .withComparatorForType(type, alwaysEqualComparator)
+                                                                       .withComparatorForType(type, alwaysDifferentComparator)
+                                                                       .getRecursiveComparisonConfiguration();
+    // THEN
+    assertThat(configuration.getComparatorForType(type)).isSameAs(alwaysDifferentComparator);
+  }
+
+}