Rename DualKey to DualValue

Author: joel-costigliola

src/main/java/org/assertj/core/api/AbstractObjectAssert.java

@@ -828,8 +828,6 @@ public RecursiveComparisonAssert<?> usingRecursiveComparison() {
     return usingRecursiveComparison(new RecursiveComparisonConfiguration());
   }
 
-  // TODO soft assertion tests: add to method changing the object under tests
-
   /**
    * Same as {@link #usingRecursiveComparison()} but allows to specify your own {@link RecursiveComparisonConfiguration}.
    * @param recursiveComparisonConfiguration the {@link RecursiveComparisonConfiguration} used in the chained {@link RecursiveComparisonAssert#isEqualTo(Object) isEqualTo} assertion.

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

@@ -50,7 +50,6 @@ void setRecursiveComparisonConfiguration(RecursiveComparisonConfiguration recurs
    * Asserts that the object under test (actual) is equal to the given object when compared field by field recursively (including
    * inherited fields are included in the comparison). If the comparison fails it will report all the differences found and which
    * effective {@link RecursiveComparisonConfiguration} was used to help users understand the failure.
-   * TODO add link to assertj website documentation
    * <p>
    * This is typically useful when actual's {@code equals} was not overridden.
    * <p>

src/main/java/org/assertj/core/api/recursive/comparison/DualKey.java renamed to src/main/java/org/assertj/core/api/recursive/comparison/DualValue.java

@@ -12,56 +12,58 @@
  */
 package org.assertj.core.api.recursive.comparison;
 
+import static java.lang.String.format;
+import static java.util.Collections.unmodifiableList;
 import static org.assertj.core.util.Strings.join;
 
 import java.util.List;
 
-final class DualKey { // TODO rename DualValue
+// logically immutable
+final class DualValue {
 
   final List<String> path;
   final String concatenatedPath;
-  final Object key1; // TODO rename to actual
-  final Object key2; // TODO rename to expected
+  final Object actual;
+  final Object expected;
+  private final int hashCode;
 
-  DualKey(List<String> path, Object key1, Object key2) {
+  DualValue(List<String> path, Object actual, Object expected) {
     this.path = path;
     this.concatenatedPath = join(path).with(".");
-    this.key1 = key1;
-    this.key2 = key2;
+    this.actual = actual;
+    this.expected = expected;
+    int h1 = actual != null ? actual.hashCode() : 0;
+    int h2 = expected != null ? expected.hashCode() : 0;
+    hashCode = h1 + h2;
   }
 
   @Override
   public boolean equals(Object other) {
-    if (!(other instanceof DualKey)) {
-      return false;
-    }
-
-    DualKey that = (DualKey) other;
-    return key1 == that.key1 && key2 == that.key2;
+    if (!(other instanceof DualValue)) return false;
+    DualValue that = (DualValue) other;
+    return actual == that.actual && expected == that.expected;
   }
 
   @Override
   public int hashCode() {
-    int h1 = key1 != null ? key1.hashCode() : 0;
-    int h2 = key2 != null ? key2.hashCode() : 0;
-    return h1 + h2;
+    return hashCode;
   }
 
-
   @Override
   public String toString() {
-    return String.format("DualKey [path=%s, key1=%s, key2=%s]", concatenatedPath, key1, key2);
+    return format("DualValue [path=%s, actual=%s, expected=%s]", concatenatedPath, actual, expected);
   }
 
   public List<String> getPath() {
-    return path;
+    return unmodifiableList(path);
   }
 
   public String getConcatenatedPath() {
     return concatenatedPath;
   }
 
   public boolean isJavaType() {
-    return key1.getClass().getName().startsWith("java.");
+    if (actual == null) return false;
+    return actual.getClass().getName().startsWith("java.");
   }
 }

src/main/java/org/assertj/core/api/recursive/comparison/DualKeyDeque.java renamed to src/main/java/org/assertj/core/api/recursive/comparison/DualValueDeque.java

@@ -18,49 +18,48 @@
 import java.util.LinkedList;
 
 // special deque that can ignore DualKey according to RecursiveComparisonConfiguration.
-// TODO: keep track of ignored fields ?
 @SuppressWarnings("serial")
-class DualKeyDeque extends LinkedList<DualKey> {
+class DualValueDeque extends LinkedList<DualValue> {
   private RecursiveComparisonConfiguration recursiveComparisonConfiguration;
 
-  public DualKeyDeque(RecursiveComparisonConfiguration recursiveComparisonConfiguration) {
+  public DualValueDeque(RecursiveComparisonConfiguration recursiveComparisonConfiguration) {
     this.recursiveComparisonConfiguration = recursiveComparisonConfiguration;
   }
 
   @Override
-  public boolean add(DualKey dualKey) {
+  public boolean add(DualValue dualKey) {
     if (shouldIgnore(dualKey)) return false;
     return super.add(dualKey);
   }
 
   @Override
-  public void add(int index, DualKey dualKey) {
+  public void add(int index, DualValue dualKey) {
     if (shouldIgnore(dualKey)) return;
     super.add(index, dualKey);
   }
 
   @Override
-  public boolean addAll(int index, Collection<? extends DualKey> collection) {
+  public boolean addAll(int index, Collection<? extends DualValue> collection) {
     return super.addAll(index, collection.stream().filter(this::shouldAddDualKey).collect(toList()));
   }
 
   @Override
-  public void addFirst(DualKey dualKey) {
+  public void addFirst(DualValue dualKey) {
     if (shouldIgnore(dualKey)) return;
     super.addFirst(dualKey);
   }
 
   @Override
-  public void addLast(DualKey dualKey) {
+  public void addLast(DualValue dualKey) {
     if (shouldIgnore(dualKey)) return;
     super.addLast(dualKey);
   }
 
-  private boolean shouldIgnore(DualKey dualKey) {
+  private boolean shouldIgnore(DualValue dualKey) {
     return recursiveComparisonConfiguration.shouldIgnore(dualKey);
   }
 
-  private boolean shouldAddDualKey(DualKey dualKey) {
+  private boolean shouldAddDualKey(DualValue dualKey) {
     return !shouldIgnore(dualKey);
   }
 

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

@@ -270,7 +270,7 @@ public String multiLineDescription(Representation representation) {
 
   // non public stuff
 
-  boolean shouldIgnore(DualKey dualKey) {
+  boolean shouldIgnore(DualValue dualKey) {
     return matchesAnIgnoredNullField(dualKey)
            || matchesAnIgnoredField(dualKey)
            || matchesAnIgnoredFieldRegex(dualKey);
@@ -289,11 +289,11 @@ private static String concatenatedPath(String parentPath, String name) {
     return parentPath.isEmpty() ? name : format("%s.%s", parentPath, name);
   }
 
-  boolean shouldIgnoreOverriddenEqualsOf(DualKey dualKey) {
+  boolean shouldIgnoreOverriddenEqualsOf(DualValue dualKey) {
     if (dualKey.isJavaType()) return false; // we must compare basic types otherwise the recursive comparison loops infinitely!
     return ignoreAllOverriddenEquals
            || matchesAnIgnoredOverriddenEqualsField(dualKey)
-           || shouldIgnoreOverriddenEqualsOf(dualKey.key1.getClass());
+           || shouldIgnoreOverriddenEqualsOf(dualKey.actual.getClass());
   }
 
   @VisibleForTesting
@@ -367,25 +367,25 @@ private boolean matchesAnIgnoredOverriddenEqualsType(Class<?> clazz) {
     return ignoredOverriddenEqualsForTypes.contains(clazz);
   }
 
-  private boolean matchesAnIgnoredOverriddenEqualsField(DualKey dualKey) {
+  private boolean matchesAnIgnoredOverriddenEqualsField(DualValue dualKey) {
     return ignoredOverriddenEqualsForFields.stream()
                                            .anyMatch(fieldLocation -> fieldLocation.matches(dualKey.concatenatedPath));
   }
 
-  private boolean matchesAnIgnoredNullField(DualKey dualKey) {
-    return ignoreAllActualNullFields && dualKey.key1 == null;
+  private boolean matchesAnIgnoredNullField(DualValue dualKey) {
+    return ignoreAllActualNullFields && dualKey.actual == null;
   }
 
   private boolean matchesAnIgnoredFieldRegex(String fieldConcatenatedPath) {
     return ignoredFieldsRegexes.stream()
                                .anyMatch(regex -> regex.matcher(fieldConcatenatedPath).matches());
   }
 
-  private boolean matchesAnIgnoredFieldRegex(DualKey dualKey) {
+  private boolean matchesAnIgnoredFieldRegex(DualValue dualKey) {
     return matchesAnIgnoredFieldRegex(dualKey.concatenatedPath);
   }
 
-  private boolean matchesAnIgnoredField(DualKey dualKey) {
+  private boolean matchesAnIgnoredField(DualValue dualKey) {
     return matchesAnIgnoredField(dualKey.concatenatedPath);
   }