How to use initDualValuesToCompare method of org.assertj.core.api.recursive.comparison.RecursiveComparisonDifferenceCalculator class

Best Assertj code snippet using org.assertj.core.api.recursive.comparison.RecursiveComparisonDifferenceCalculator.initDualValuesToCompare

Source:RecursiveComparisonDifferenceCalculator.java

...93    }94    private void registerForComparison(DualValue dualValue) {95      if (!visitedDualValues.contains(dualValue)) dualValuesToCompare.addFirst(dualValue);96    }97    private void initDualValuesToCompare(Object actual, Object expected, List<String> parentPath, boolean isRootObject) {98      DualValue dualValue = new DualValue(parentPath, actual, expected);99      boolean mustCompareFieldsRecursively = mustCompareFieldsRecursively(isRootObject, dualValue);100      if (dualValue.hasNoNullValues() && dualValue.hasNoContainerValues() && mustCompareFieldsRecursively) {101        // disregard the equals method and start comparing fields102        Set<String> nonIgnoredActualFieldsNames = recursiveComparisonConfiguration.getNonIgnoredActualFieldNames(dualValue);103        if (!nonIgnoredActualFieldsNames.isEmpty()) {104          // fields to ignore are evaluated when adding their corresponding dualValues to dualValuesToCompare which filters105          // ignored fields according to recursiveComparisonConfiguration106          Set<String> expectedFieldsNames = getFieldsNames(expected.getClass());107          if (expectedFieldsNames.containsAll(nonIgnoredActualFieldsNames)) {108            // we compare actual fields vs expected, ignoring expected additional fields109            for (String nonIgnoredActualFieldName : nonIgnoredActualFieldsNames) {110              DualValue fieldDualValue = new DualValue(parentPath, nonIgnoredActualFieldName,111                                                       COMPARISON.getSimpleValue(nonIgnoredActualFieldName, actual),112                                                       COMPARISON.getSimpleValue(nonIgnoredActualFieldName, expected));113              dualValuesToCompare.addFirst(fieldDualValue);114            }115          } else {116            dualValuesToCompare.addFirst(dualValue);117          }118        } else {119          dualValuesToCompare.addFirst(dualValue);120        }121      } else {122        dualValuesToCompare.addFirst(dualValue);123      }124      // We need to remove already visited fields pair to avoid infinite recursion in case125      // parent -> set{child} with child having a reference back to parent126      // it occurs to unordered collection where we compare all possible combination of the collection elements recursively127      // --128      // remove visited values one by one, DualValue.equals correctly compare respective actual and expected fields by reference129      visitedDualValues.forEach(visitedDualValue -> dualValuesToCompare.stream()130                                                                       .filter(dualValueToCompare -> dualValueToCompare.equals(visitedDualValue))131                                                                       .findFirst()132                                                                       .ifPresent(dualValuesToCompare::remove));133    }134    private boolean mustCompareFieldsRecursively(boolean isRootObject, DualValue dualValue) {135      boolean noCustomComparisonForDualValue = !recursiveComparisonConfiguration.hasCustomComparator(dualValue)136                                               && !shouldHonorOverriddenEquals(dualValue, recursiveComparisonConfiguration);137      return isRootObject || noCustomComparisonForDualValue;138    }139  }140  /**141   * Compare two objects for differences by doing a 'deep' comparison. This will traverse the142   * Object graph and perform either a field-by-field comparison on each143   * object (if not .equals() method has been overridden from Object), or it144   * will call the customized .equals() method if it exists.145   * <p>146   *147   * This method handles cycles correctly, for example A-&gt;B-&gt;C-&gt;A.148   * Suppose a and a' are two separate instances of the A with the same values149   * for all fields on A, B, and C. Then a.deepEquals(a') will return an empty list. It150   * uses cycle detection storing visited objects in a Set to prevent endless151   * loops.152   *153   * @param actual Object one to compare154   * @param expected Object two to compare155   * @param recursiveComparisonConfiguration the recursive comparison configuration156   * @return the list of differences found or an empty list if objects are equivalent.157   *         Equivalent means that all field values of both subgraphs are the same,158   *         either at the field level or via the respectively encountered overridden159   *         .equals() methods during traversal.160   */161  public List<ComparisonDifference> determineDifferences(Object actual, Object expected,162                                                         RecursiveComparisonConfiguration recursiveComparisonConfiguration) {163    if (recursiveComparisonConfiguration.isInStrictTypeCheckingMode() && expectedTypeIsNotSubtypeOfActualType(actual, expected)) {164      return list(expectedAndActualTypeDifference(actual, expected));165    }166    List<String> rootPath = list();167    List<DualValue> visited = list();168    return determineDifferences(actual, expected, rootPath, true, visited, recursiveComparisonConfiguration);169  }170  // TODO keep track of ignored fields in an RecursiveComparisonExecution class ?171  private static List<ComparisonDifference> determineDifferences(Object actual, Object expected, List<String> parentPath,172                                                                 boolean isRootObject, List<DualValue> visited,173                                                                 RecursiveComparisonConfiguration recursiveComparisonConfiguration) {174    ComparisonState comparisonState = new ComparisonState(visited, recursiveComparisonConfiguration);175    comparisonState.initDualValuesToCompare(actual, expected, parentPath, isRootObject);176    while (comparisonState.hasDualValuesToCompare()) {177      final DualValue dualValue = comparisonState.pickDualValueToCompare();178      final List<String> currentPath = dualValue.getPath();179      final Object actualFieldValue = dualValue.actual;180      final Object expectedFieldValue = dualValue.expected;181      if (actualFieldValue == expectedFieldValue) continue;182      // Custom comparators take precedence over all other types of comparison183      if (recursiveComparisonConfiguration.hasCustomComparator(dualValue)) {184        if (!propertyOrFieldValuesAreEqual(dualValue, recursiveComparisonConfiguration)) comparisonState.addDifference(dualValue);185        // since we used a custom comparator we don't need to inspect the nested fields any further186        continue;187      }188      if (actualFieldValue == null || expectedFieldValue == null) {189        // one of the value is null while the other is not as we already know that actualFieldValue != expectedFieldValue...

initDualValuesToCompare

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2import static org.assertj.core.api.Assertions.within;3import static org.assertj.core.api.recursive.comparison.RecursiveComparisonConfiguration.builder;4import static org.assertj.core.api.recursive.comparison.RecursiveComparisonDifferenceCalculator.initDualValuesToCompare;5import static org.assertj.core.data.Percentage.withPercentage;6import java.math.BigDecimal;7import java.util.ArrayList;8import java.util.List;9import org.assertj.core.api.recursive.comparison.DualValue;10import org.assertj.core.api.recursive.comparison.RecursiveComparisonDifference;11import org.assertj.core.api.recursive.comparison.RecursiveComparisonDifferenceCalculator;12import org.assertj.core.data.Percentage;13import org.assertj.core.internal.DeepDifference.Difference;14import org.assertj.core.internal.DeepDifference.Difference.Kind;15import org.junit.Test;16public class TestRecursiveComparisonDifferenceCalculator {17    public void testInitDualValuesToCompare() {18        RecursiveComparisonDifferenceCalculator recursiveComparisonDifferenceCalculator = new RecursiveComparisonDifferenceCalculator();19        List<Difference> differences = new ArrayList<>();20        differences.add(new Difference("field1", Kind.ENTRY_VALUE, 1, 2));21        differences.add(new Difference("field2", Kind.ENTRY_VALUE, 1.1, 1.2));22        differences.add(new Difference("field3", Kind.ENTRY_VALUE, 1.1f, 1.2f));23        differences.add(new Difference("field4", Kind.ENTRY_VALUE, new BigDecimal("1.1"), new BigDecimal("1.2")));24        differences.add(new Difference("field5", Kind.ENTRY_VALUE, "1.1", "1.2"));25        differences.add(new Difference("field6", Kind.ENTRY_VALUE, true, false));26        differences.add(new Difference("field7", Kind.ENTRY_VALUE, (byte) 1, (byte) 2));27        differences.add(new Difference("field8", Kind.ENTRY_VALUE, (short) 1, (short) 2));28        differences.add(new Difference("field9", Kind.ENTRY_VALUE, (long) 1, (long) 2));29        differences.add(new Difference("field10", Kind.ENTRY_VALUE, 'a', 'b'));30        differences.add(new Difference("field11", Kind.ENTRY_VALUE, new int[] { 1, 2, 3 }, new int[] { 1, 2, 3 }));31        differences.add(new Difference("field12", Kind.ENTRY_VALUE

initDualValuesToCompare

Using AI Code Generation

1import org.assertj.core.api.recursive.comparison.RecursiveComparisonDifferenceCalculator;2public class AssertJRecursiveComparisonDifferenceCalculator {3    public static void main(String[] args) {4        RecursiveComparisonDifferenceCalculator recursiveComparisonDifferenceCalculator = new RecursiveComparisonDifferenceCalculator();5        recursiveComparisonDifferenceCalculator.initDualValuesToCompare("a", "b");6        System.out.println(recursiveComparisonDifferenceCalculator);7    }8}

initDualValuesToCompare

Using AI Code Generation

1public void shouldCompareObjectWithDifferentValues() {2    Address address = new Address("street", 10);3    Person person = new Person("John", 30, address);4    RecursiveComparisonDifference recursiveComparisonDifference = initDualValuesToCompare(person, person);5    assertThat(recursiveComparisonDifference).isNull();6}7public void shouldCompareObjectWithDifferentValues() {8    Address address = new Address("street", 10);9    Person person = new Person("John", 30, address);10    RecursiveComparisonDifference recursiveComparisonDifference = initDualValuesToCompare(person, person);11    assertThat(recursiveComparisonDifference).isNull();12}13public void shouldCompareObjectWithDifferentValues() {14    Address address = new Address("street", 10);15    Person person = new Person("John", 30, address);16    RecursiveComparisonDifference recursiveComparisonDifference = initDualValuesToCompare(person, person);17    assertThat(recursiveComparisonDifference).isNull();18}19public void shouldCompareObjectWithDifferentValues() {20    Address address = new Address("street", 10);21    Person person = new Person("John", 30, address);22    RecursiveComparisonDifference recursiveComparisonDifference = initDualValuesToCompare(person, person);23    assertThat(recursiveComparisonDifference).isNull();24}25public void shouldCompareObjectWithDifferentValues() {26    Address address = new Address("street", 10);27    Person person = new Person("John", 30, address);28    RecursiveComparisonDifference recursiveComparisonDifference = initDualValuesToCompare(person, person);29    assertThat(recursiveComparisonDifference).isNull();30}

initDualValuesToCompare

Using AI Code Generation

1import java.util.*;2import org.assertj.core.api.recursive.comparison.*;3public class Test {4    public static void main(String[] args) {5        List<String> list1 = Arrays.asList("a", "b", "c");6        List<String> list2 = Arrays.asList("a", "b", "c");7        RecursiveComparisonDifferenceCalculator calc = new RecursiveComparisonDifferenceCalculator();8        calc.initDualValuesToCompare(list1, list2);9        List<RecursiveComparisonDifference> diffs = calc.compare(list1, list2);10        System.out.println(diffs);11    }12}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.