Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use determineDifferencesWith method of org.assertj.core.api.RecursiveComparisonAssert class

Best Assertj code snippet using org.assertj.core.api.RecursiveComparisonAssert.determineDifferencesWith

Source:RecursiveComparisonAssert.java

...148    }149    // at this point expected is not null, which means actual must not be null for the assertion to pass150    objects.assertNotNull(info, actual);151    // at this point both actual and expected are not null, we can compare them recursively!152    List<ComparisonDifference> differences = determineDifferencesWith(expected);153    if (!differences.isEmpty()) throw objects.getFailures().failure(info, shouldBeEqualByComparingFieldByFieldRecursively(actual,154                                                                                                                          expected,155                                                                                                                          differences,156                                                                                                                          recursiveComparisonConfiguration,157                                                                                                                          info.representation()));158    return myself;159  }160  /**161   * Asserts that actual object is not equal to the given object based on a recursive property/field by property/field comparison162   * (including inherited ones).163   * <p>164   * This is typically useful when actual's {@code equals} was not overridden.165   * <p>166   * The comparison is <b>not symmetrical</b> since it is <b>limited to actual's fields</b>, the algorithm gather all167   * actual's fields and then compare them to the corresponding expected's fields.<br>168   * It is then possible for the expected object to have more fields than actual which is handy when comparing169   * a base type to a subtype.170   * <p>171   * This method is based on {@link #isEqualTo(Object)}, you can check out more usages in that method.172   * <p>173   * Example174   * <pre><code class='java'> // equals not overridden in TolkienCharacter175   * TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);176   * TolkienCharacter frodoClone = new TolkienCharacter("Frodo", 33, HOBBIT);177   * TolkienCharacter youngFrodo = new TolkienCharacter("Frodo", 22, HOBBIT);178   *179   * // Pass as equals compares object references180   * assertThat(frodo).isNotEqualTo(frodoClone);181   *182   * // Fail as frodo and frodoClone are equals when doing a field by field comparison.183   * assertThat(frodo).usingRecursiveComparison()184   *                  .isNotEqualTo(frodoClone);185   *186   * // Pass as one the age fields differ between frodo and youngFrodo.187   * assertThat(frodo).usingRecursiveComparison()188   *                  .isNotEqualTo(youngFrodo);</code></pre>189   *190   * @param other the object to compare {@code actual} to.191   * @return {@code this} assertions object192   * @throws AssertionError if the actual object and the given objects are both {@code null}.193   * @throws AssertionError if the actual and the given objects are equals property/field by property/field recursively.194   * @see #isEqualTo(Object)195   * @since 3.17.0196   */197  @Override198  public SELF isNotEqualTo(Object other) {199    if (actual == other) throw objects.getFailures().failure(info,200                                                             shouldNotBeEqualComparingFieldByFieldRecursively(actual, other,201                                                                                                              recursiveComparisonConfiguration,202                                                                                                              info.representation()));203    if (other != null && actual != null) {204      List<ComparisonDifference> differences = determineDifferencesWith(other);205      if (differences.isEmpty())206        throw objects.getFailures().failure(info,207                                            shouldNotBeEqualComparingFieldByFieldRecursively(actual, other,208                                                                                             recursiveComparisonConfiguration,209                                                                                             info.representation()));210    }211    // either one of actual or other was null (but not both) or there were no differences212    return myself;213  }214  /**215   * Makes the recursive comparison to ignore all <b>actual null fields</b> (but note that the expected object null fields are used in the comparison).216   * <p>217   * Example:218   * <pre><code class='java'> public class Person {219   *   String name;220   *   double height;221   *   Home home = new Home();222   * }223   *224   * public class Home {225   *   Address address = new Address();226   * }227   *228   * public static class Address {229   *   int number;230   *   String street;231   * }232   *233   * Person noName = new Person(null, 1.80);234   * noName.home.address.street = null;235   * noName.home.address.number = 221;236   *237   * Person sherlock = new Person("Sherlock", 1.80);238   * sherlock.home.address.street = "Baker Street";239   * sherlock.home.address.number = 221;240   *241   * // assertion succeeds as name and home.address.street fields are ignored in the comparison242   * assertThat(noName).usingRecursiveComparison()243   *                   .ignoringActualNullFields()244   *                   .isEqualTo(sherlock);245   *246   * // assertion fails as name and home.address.street fields are populated for sherlock but not for noName.247   * assertThat(sherlock).usingRecursiveComparison()248   *                     .ignoringActualNullFields()249   *                     .isEqualTo(noName);</code></pre>250   *251   * @return this {@link RecursiveComparisonAssert} to chain other methods.252   */253  @CheckReturnValue254  public SELF ignoringActualNullFields() {255    recursiveComparisonConfiguration.setIgnoreAllActualNullFields(true);256    return myself;257  }258  /**259   * Makes the recursive comparison to ignore all <b>actual empty optional fields</b> (including {@link Optional}, {@link OptionalInt}, {@link OptionalLong} and {@link OptionalDouble}),260   * note that the expected object empty optional fields are not ignored, this only applies to actual's fields.261   * <p>262   * Example:263   * <pre><code class='java'> public class Person {264   *   String name;265   *   OptionalInt age;266   *   OptionalLong id;267   *   OptionalDouble height;268   *   Home home = new Home();269   * }270   *271   * public class Home {272   *   String address;273   *   Optional&lt;String&gt; phone;274   * }275   *276   * Person homerWithoutDetails = new Person("Homer Simpson");277   * homerWithoutDetails.home.address.street = "Evergreen Terrace";278   * homerWithoutDetails.home.address.number = 742;279   * homerWithoutDetails.home.phone = Optional.empty();280   * homerWithoutDetails.age = OptionalInt.empty();281   * homerWithoutDetails.id = OptionalLong.empty();282   * homerWithoutDetails.height = OptionalDouble.empty();283   *284   * Person homerWithDetails = new Person("Homer Simpson");285   * homerWithDetails.home.address.street = "Evergreen Terrace";286   * homerWithDetails.home.address.number = 742;287   * homerWithDetails.home.phone = Optional.of("(939) 555-0113");288   * homerWithDetails.age = OptionalInt.of(39);289   * homerWithDetails.id = OptionalLong.of(123456);290   * homerWithDetails.height = OptionalDouble.of(1.83);291   *292   * // assertion succeeds as phone is ignored in the comparison293   * assertThat(homerWithoutDetails).usingRecursiveComparison()294   *                                .ignoringActualEmptyOptionalFields()295   *                                .isEqualTo(homerWithDetails);296   *297   * // assertion fails as phone, age, id and height are not ignored and are populated for homerWithDetails but not for homerWithoutDetails.298   * assertThat(homerWithDetails).usingRecursiveComparison()299   *                             .ignoringActualEmptyOptionalFields()300   *                             .isEqualTo(homerWithoutDetails);</code></pre>301   *302   * @return this {@link RecursiveComparisonAssert} to chain other methods.303   */304  @CheckReturnValue305  public SELF ignoringActualEmptyOptionalFields() {306    recursiveComparisonConfiguration.setIgnoreAllActualEmptyOptionalFields(true);307    return myself;308  }309  /**310   * Makes the recursive comparison to ignore all <b>expected null fields</b>.311   * <p>312   * Example:313   * <pre><code class='java'> public class Person {314   *   String name;315   *   double height;316   *   Home home = new Home();317   * }318   *319   * public class Home {320   *   Address address = new Address();321   * }322   *323   * public static class Address {324   *   int number;325   *   String street;326   * }327   *328   * Person sherlock = new Person("Sherlock", 1.80);329   * sherlock.home.address.street = "Baker Street";330   * sherlock.home.address.number = 221;331   *332   * Person noName = new Person(null, 1.80);333   * noName.home.address.street = null;334   * noName.home.address.number = 221;335   *336   * // assertion succeeds as name and home.address.street fields are ignored in the comparison337   * assertThat(sherlock).usingRecursiveComparison()338   *                     .ignoringExpectedNullFields()339   *                     .isEqualTo(noName);340   *341   * // assertion fails as name and home.address.street fields are populated for sherlock but not for noName.342   * assertThat(noName).usingRecursiveComparison()343   *                   .ignoringExpectedNullFields()344   *                   .isEqualTo(sherlock);</code></pre>345   *346   * @return this {@link RecursiveComparisonAssert} to chain other methods.347   */348  @CheckReturnValue349  public SELF ignoringExpectedNullFields() {350    recursiveComparisonConfiguration.setIgnoreAllExpectedNullFields(true);351    return myself;352  }353  /**354   * Makes the recursive comparison to ignore the given object under test fields. Nested fields can be specified like this: {@code home.address.street}.355   * <p>356   * Example:357   * <pre><code class='java'> public class Person {358   *   String name;359   *   double height;360   *   Home home = new Home();361   * }362   *363   * public class Home {364   *   Address address = new Address();365   * }366   *367   * public static class Address {368   *   int number;369   *   String street;370   * }371   *372   * Person sherlock = new Person("Sherlock", 1.80);373   * sherlock.home.address.street = "Baker Street";374   * sherlock.home.address.number = 221;375   *376   * Person noName = new Person(null, 1.80);377   * noName.home.address.street = null;378   * noName.home.address.number = 221;379   *380   * // assertion succeeds as name and home.address.street fields are ignored in the comparison381   * assertThat(sherlock).usingRecursiveComparison()382   *                     .ignoringFields("name", "home.address.street")383   *                     .isEqualTo(noName);384   *385   * // assertion fails as home.address.street fields differ and is not ignored.386   * assertThat(sherlock).usingRecursiveComparison()387   *                     .ignoringFields("name")388   *                     .isEqualTo(noName);</code></pre>389   *390   * @param fieldsToIgnore the fields of the object under test to ignore in the comparison.391   * @return this {@link RecursiveComparisonAssert} to chain other methods.392   */393  @CheckReturnValue394  public SELF ignoringFields(String... fieldsToIgnore) {395    recursiveComparisonConfiguration.ignoreFields(fieldsToIgnore);396    return myself;397  }398  /**399   * Makes the recursive comparison to ignore the object under test fields matching the given regexes.400   * <p>401   * Nested fields can be specified by using dots like this: {@code home\.address\.street} ({@code \} is used to escape402   * dots since they have a special meaning in regexes).403   * <p>404   * Example:405   * <pre><code class='java'> public class Person {406   *   String name;407   *   double height;408   *   Home home = new Home();409   * }410   *411   * public class Home {412   *   Address address = new Address();413   * }414   *415   * public static class Address {416   *   int number;417   *   String street;418   * }419   *420   * Person sherlock = new Person("Sherlock", 1.80);421   * sherlock.home.address.street = "Baker Street";422   * sherlock.home.address.number = 221;423   *424   * Person noName = new Person(null, 1.80);425   * noName.home.address.street = "Butcher Street";426   * noName.home.address.number = 222;427   *428   * // assertion succeeds as name and all home fields are ignored in the comparison429   * assertThat(sherlock).usingRecursiveComparison()430   *                     .ignoringFieldsMatchingRegexes("n.me", "home.*")431   *                     .isEqualTo(noName);432   *433   * // although home fields are ignored, assertion fails as name fields differ.434   * assertThat(sherlock).usingRecursiveComparison()435   *                     .ignoringFieldsMatchingRegexes("home.*")436   *                     .isEqualTo(noName);</code></pre>437   *438   * @param regexes regexes used to ignore fields in the comparison.439   * @return this {@link RecursiveComparisonAssert} to chain other methods.440   */441  @CheckReturnValue442  public SELF ignoringFieldsMatchingRegexes(String... regexes) {443    recursiveComparisonConfiguration.ignoreFieldsMatchingRegexes(regexes);444    return myself;445  }446  /**447   * Makes the recursive comparison to ignore the object under test fields of the given types.448   * 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.449   * <p>450   * If some object under test fields are null it is not possible to evaluate their types unless in {@link #withStrictTypeChecking() strictTypeChecking mode},451   * in that case the corresponding expected field's type is evaluated instead but if strictTypeChecking mode is disabled then null fields are not ignored.452   * <p>453   * Example:454   * <pre><code class='java'> public class Person {455   *   String name;456   *   double height;457   *   Home home = new Home();458   * }459   *460   * public class Home {461   *   Address address = new Address();462   * }463   *464   * public static class Address {465   *   int number;466   *   String street;467   * }468   *469   * Person sherlock = new Person("Sherlock", 1.80);470   * sherlock.home.address.street = "Baker Street";471   * sherlock.home.address.number = 221;472   *473   * Person sherlock2 = new Person("Sherlock", 1.90);474   * sherlock2.home.address.street = "Butcher Street";475   * sherlock2.home.address.number = 221;476   *477   * // assertion succeeds as we ignore Address and height478   * assertThat(sherlock).usingRecursiveComparison()479   *                     .ignoringFieldsOfTypes(double.class, Address.class)480   *                     .isEqualTo(sherlock2);481   *482   * // now this assertion fails as expected since the home.address.street fields and height differ483   * assertThat(sherlock).usingRecursiveComparison()484   *                     .isEqualTo(sherlock2);</code></pre>485   *486   * @param typesToIgnore the types we want to ignore in the object under test fields.487   * @return this {@link RecursiveComparisonAssert} to chain other methods.488   */489  public RecursiveComparisonAssert<?> ignoringFieldsOfTypes(Class<?>... typesToIgnore) {490    recursiveComparisonConfiguration.ignoreFieldsOfTypes(typesToIgnore);491    return myself;492  }493  /**494   * This method instructs the recursive comparison to compare recursively all fields including the one whose type have overridden equals,495   * <b>except fields with java types</b> (at some point we need to compare something!).496   * <p>497   * Since 3.17.0 this is the default behavior for recursive comparisons, to revert to the previous behavior call {@link #usingOverriddenEquals()}.498   * <p>499   * Example:500   * <pre><code class='java'> public class Person {501   *   String name;502   *   double height;503   *   Home home = new Home();504   * }505   *506   * public class Home {507   *   Address address = new Address();508   * }509   *510   * public static class Address {511   *   int number;512   *   String street;513   *514   *   // only compares number, ouch!515   *   {@literal @}Override516   *   public boolean equals(final Object other) {517   *     if (!(other instanceof Address)) return false;518   *     Address castOther = (Address) other;519   *     return Objects.equals(number, castOther.number);520   *   }521   * }522   *523   * Person sherlock = new Person("Sherlock", 1.80);524   * sherlock.home.address.street = "Baker Street";525   * sherlock.home.address.number = 221;526   *527   * Person sherlock2 = new Person("Sherlock", 1.80);528   * sherlock2.home.address.street = "Butcher Street";529   * sherlock2.home.address.number = 221;530   *531   * // Assertion succeeds because:532   * // - overridden equals are used533   * // - Address has overridden equals and does not compare street fields.534   * assertThat(sherlock).usingRecursiveComparison()535   *                     .usingOverriddenEquals()536   *                     .isEqualTo(sherlock2);537   *538   * // To avoid using Address overridden equals, don't call usingOverriddenEquals() or call ignoringAllOverriddenEquals()539   * // (calling ignoringAllOverriddenEquals() is actually not required as this is the default behavior).540   * // This assertion fails as it will compare home.address.street fields which differ541   * assertThat(sherlock).usingRecursiveComparison()542   *                      //.ignoringAllOverriddenEquals() // not needed as this is the default543   *                     .isEqualTo(sherlock2);</code></pre>544   *545   * @return this {@link RecursiveComparisonAssert} to chain other methods.546   */547  public SELF ignoringAllOverriddenEquals() {548    recursiveComparisonConfiguration.ignoreAllOverriddenEquals();549    return myself;550  }551  /**552   * By default the recursive comparison compare recursively all fields including the ones whose type have overridden equals553   * <b>except fields with java types</b> (at some point we need to compare something!).554   * <p>555   * This method instructs the recursive comparison to use overridden equals.556   * <p>557   * Example:558   * <pre><code class='java'> public class Person {559   *   String name;560   *   double height;561   *   Home home = new Home();562   * }563   *564   * public class Home {565   *   Address address = new Address();566   * }567   *568   * public static class Address {569   *   int number;570   *   String street;571   *572   *   // only compares number!573   *   {@literal @}Override574   *   public boolean equals(final Object other) {575   *     if (!(other instanceof Address)) return false;576   *     Address castOther = (Address) other;577   *     return Objects.equals(number, castOther.number);578   *   }579   * }580   *581   * Person sherlock = new Person("Sherlock", 1.80);582   * sherlock.home.address.street = "Baker Street";583   * sherlock.home.address.number = 221;584   *585   * Person sherlock2 = new Person("Sherlock", 1.80);586   * sherlock2.home.address.street = "Butcher Street";587   * sherlock2.home.address.number = 221;588   *589   * // assertion succeeds because Address equals does not compare street fields.590   * assertThat(sherlock).usingRecursiveComparison()591   *                     .usingOverriddenEquals()592   *                     .isEqualTo(sherlock2);593   *594   * // Assertion fails because:595   * // - Address equals is not used.596   * // - street fields are compared and differ.597   * assertThat(sherlock).usingRecursiveComparison()598   *                     .isEqualTo(sherlock2);</code></pre>599   *600   * @return this {@link RecursiveComparisonAssert} to chain other methods.601   * @since 3.17.0602   */603  public SELF usingOverriddenEquals() {604    recursiveComparisonConfiguration.useOverriddenEquals();605    return myself;606  }607  /**608   * In case you have instructed the recursive to use overridden {@code equals} with {@link #usingOverriddenEquals()},609   * this method allows to ignore overridden {@code equals} for the given fields (it adds them to the already registered ones).610   * <p>611   * Since 3.17.0 all overridden {@code equals} so this method is only relevant if you have called {@link #usingOverriddenEquals()} before.612   * <p>613   * Nested fields can be specified by using dots like this: {@code home.address.street}614   * <p>615   * Example:616   * <pre><code class='java'> public class Person {617   *   String name;618   *   double height;619   *   Home home = new Home();620   * }621   *622   * public class Home {623   *   Address address = new Address();624   * }625   *626   * public static class Address {627   *   int number;628   *   String street;629   *630   *   // only compares number631   *   {@literal @}Override632   *   public boolean equals(final Object other) {633   *     if (!(other instanceof Address)) return false;634   *     Address castOther = (Address) other;635   *     return Objects.equals(number, castOther.number);636   *   }637   * }638   *639   * Person sherlock = new Person("Sherlock", 1.80);640   * sherlock.home.address.street = "Baker Street";641   * sherlock.home.address.number = 221;642   *643   * Person sherlock2 = new Person("Sherlock", 1.80);644   * sherlock2.home.address.street = "Butcher Street";645   * sherlock2.home.address.number = 221;646   *647   * // Assertion succeeds because:648   * // - overridden equals are used649   * // - Address has overridden equals and does not compare street fields.650   * assertThat(sherlock).usingRecursiveComparison()651   *                     .usingOverriddenEquals()652   *                     .isEqualTo(sherlock2);653   *654   * // ignoringOverriddenEqualsForFields force a recursive comparison on the given field655   * // Assertion fails because:656   * // - Address equals is not used.657   * // - street fields are compared and differ.658   * assertThat(sherlock).usingRecursiveComparison()659   *                     .usingOverriddenEquals()660   *                     .ignoringOverriddenEqualsForFields("home.address")661   *                     .isEqualTo(sherlock2);</code></pre>662   *663   * @param fields the fields we want to force a recursive comparison on.664   * @return this {@link RecursiveComparisonAssert} to chain other methods.665   */666  @CheckReturnValue667  public SELF ignoringOverriddenEqualsForFields(String... fields) {668    recursiveComparisonConfiguration.ignoreOverriddenEqualsForFields(fields);669    return myself;670  }671  /**672   * By default the recursive comparison uses overridden {@code equals} methods to compare fields,673   * this method allows to force a recursive comparison for all fields of the given types (it adds them to the already registered ones).674   * <p>675   * Since 3.17.0 all overridden {@code equals} so this method is only relevant if you have called {@link #usingOverriddenEquals()} before.676   * <p>677   * Example:678   * <pre><code class='java'> public class Person {679   *   String name;680   *   double height;681   *   Home home = new Home();682   * }683   *684   * public class Home {685   *   Address address = new Address();686   * }687   *688   * public static class Address {689   *   int number;690   *   String street;691   *692   *   // only compares number, ouch!693   *   {@literal @}Override694   *   public boolean equals(final Object other) {695   *     if (!(other instanceof Address)) return false;696   *     Address castOther = (Address) other;697   *     return Objects.equals(number, castOther.number);698   *   }699   * }700   *701   * Person sherlock = new Person("Sherlock", 1.80);702   * sherlock.home.address.street = "Baker Street";703   * sherlock.home.address.number = 221;704   *705   * Person sherlock2 = new Person("Sherlock", 1.80);706   * sherlock2.home.address.street = "Butcher Street";707   * sherlock2.home.address.number = 221;708   *709   * // Assertion succeeds because:710   * // - overridden equals are used711   * // - Address has overridden equals and does not compare street fields.712   * assertThat(sherlock).usingRecursiveComparison()713   *                     .usingOverriddenEquals()714   *                     .isEqualTo(sherlock2);715   *716   * // ignoringOverriddenEqualsForTypes force a recursive comparison on the given types.717   * // Assertion fails because:718   * // - Address equals is not used.719   * // - street fields are compared and differ.720   * assertThat(sherlock).usingRecursiveComparison()721   *                     .usingOverriddenEquals()722   *                     .ignoringOverriddenEqualsForTypes(Address.class)723   *                     .isEqualTo(sherlock2);</code></pre>724   *725   * @param types the types we want to force a recursive comparison on.726   * @return this {@link RecursiveComparisonAssert} to chain other methods.727   */728  @CheckReturnValue729  public SELF ignoringOverriddenEqualsForTypes(Class<?>... types) {730    recursiveComparisonConfiguration.ignoreOverriddenEqualsForTypes(types);731    return myself;732  }733  /**734   * In case you have instructed the recursive to use overridden {@code equals} with {@link #usingOverriddenEquals()},735   * this method allows to force a recursive comparison for the fields matching the given regexes (it adds them to the already registered ones).736   * <p>737   * Since 3.17.0 all overridden {@code equals} so this method is only relevant if you have called {@link #usingOverriddenEquals()} before.738   * <p>739   * Nested fields can be specified by using dots like: {@code home\.address\.street} ({@code \} is used to escape740   * dots since they have a special meaning in regexes).741   * <p>742   * Example:743   * <pre><code class='java'> public class Person {744   *   String name;745   *   double height;746   *   Home home = new Home();747   * }748   *749   * public class Home {750   *   Address address = new Address();751   * }752   *753   * public static class Address {754   *   int number;755   *   String street;756   *757   *   // only compares number, ouch!758   *   {@literal @}Override759   *   public boolean equals(final Object other) {760   *     if (!(other instanceof Address)) return false;761   *     Address castOther = (Address) other;762   *     return Objects.equals(number, castOther.number);763   *   }764   * }765   *766   * Person sherlock = new Person("Sherlock", 1.80);767   * sherlock.home.address.street = "Baker Street";768   * sherlock.home.address.number = 221;769   *770   * Person sherlock2 = new Person("Sherlock", 1.80);771   * sherlock2.home.address.street = "Butcher Street";772   * sherlock2.home.address.number = 221;773   *774   * // assertion succeeds because overridden equals are used and thus street fields are mot compared775   * assertThat(sherlock).usingRecursiveComparison()776   *                     .usingOverriddenEquals()777   *                     .isEqualTo(sherlock2);778   *779   * // ignoringOverriddenEqualsForFields force a recursive comparison on the field matching the regex780   * // now this assertion fails as we expect since the home.address.street fields differ781   * assertThat(sherlock).usingRecursiveComparison()782   *                     .usingOverriddenEquals()783   *                     .ignoringOverriddenEqualsForFieldsMatchingRegexes("home.*")784   *                     .isEqualTo(sherlock2);</code></pre>785   *786   * @param regexes regexes used to specify the fields we want to force a recursive comparison on.787   * @return this {@link RecursiveComparisonAssert} to chain other methods.788   */789  @CheckReturnValue790  public SELF ignoringOverriddenEqualsForFieldsMatchingRegexes(String... regexes) {791    recursiveComparisonConfiguration.ignoreOverriddenEqualsForFieldsMatchingRegexes(regexes);792    return myself;793  }794  /**795   * Makes the recursive comparison to ignore collection order in all fields in the object under test.796   * <p>797   * Example:798   * <pre><code class='java'> public class Person {799   *   String name;800   *   List&lt;Person&gt; friends = new ArrayList&lt;&gt;();801   * }802   *803   * Person sherlock1 = new Person("Sherlock Holmes");804   * sherlock1.friends.add(new Person("Dr. John Watson"));805   * sherlock1.friends.add(new Person("Molly Hooper"));806   *807   * Person sherlock2 = new Person("Sherlock Holmes");808   * sherlock2.friends.add(new Person("Molly Hooper"));809   * sherlock2.friends.add(new Person("Dr. John Watson"));810   *811   * // assertion succeeds as all fields collection order is ignored in the comparison812   * assertThat(sherlock1).usingRecursiveComparison()813   *                      .ignoringCollectionOrder()814   *                      .isEqualTo(sherlock2);815   *816   * // assertion fails as fields collection order is not ignored in the comparison817   * assertThat(sherlock1).usingRecursiveComparison()818   *                      .isEqualTo(sherlock2);</code></pre>819   *820   * @return this {@link RecursiveComparisonAssert} to chain other methods.821   */822  @CheckReturnValue823  public SELF ignoringCollectionOrder() {824    recursiveComparisonConfiguration.ignoreCollectionOrder(true);825    return myself;826  }827  /**828   * Makes the recursive comparison to ignore collection order in the object under test specified fields. Nested fields can be specified like this: {@code home.address.street}.829   * <p>830   * Example:831   * <pre><code class='java'> public class Person {832   *   String name;833   *   List&lt;Person&gt; friends = new ArrayList&lt;&gt;();834   *   List&lt;Person&gt; enemies = new ArrayList&lt;&gt;();835   * }836   *837   * Person sherlock1 = new Person("Sherlock Holmes");838   * sherlock1.friends.add(new Person("Dr. John Watson"));839   * sherlock1.friends.add(new Person("Molly Hooper"));840   * sherlock1.enemies.add(new Person("Jim Moriarty"));841   * sherlock1.enemies.add(new Person("Irene Adler"));842   *843   * Person sherlock2 = new Person("Sherlock Holmes");844   * sherlock2.friends.add(new Person("Molly Hooper"));845   * sherlock2.friends.add(new Person("Dr. John Watson"));846   * sherlock2.enemies.add(new Person("Irene Adler"));847   * sherlock2.enemies.add(new Person("Jim Moriarty"));848   *849   * // assertion succeeds as friends and enemies fields collection order is ignored in the comparison850   * assertThat(sherlock1).usingRecursiveComparison()851   *                      .ignoringCollectionOrderInFields("friends", "enemies")852   *                      .isEqualTo(sherlock2);853   *854   * // assertion fails as enemies field collection order differ and it is not ignored855   * assertThat(sherlock1).usingRecursiveComparison()856   *                      .ignoringCollectionOrderInFields("friends")857   *                      .isEqualTo(sherlock2);</code></pre>858   *859   * @param fieldsToIgnoreCollectionOrder the fields of the object under test to ignore collection order in the comparison.860   * @return this {@link RecursiveComparisonAssert} to chain other methods.861   */862  @CheckReturnValue863  public SELF ignoringCollectionOrderInFields(String... fieldsToIgnoreCollectionOrder) {864    recursiveComparisonConfiguration.ignoreCollectionOrderInFields(fieldsToIgnoreCollectionOrder);865    return myself;866  }867  /**868   * Makes the recursive comparison to ignore collection order in the object under test fields matching the specified regexes.869   * <p>870   * Nested fields can be specified by using dots like this: {@code home\.address\.street} ({@code \} is used to escape871   * dots since they have a special meaning in regexes).872   * <p>873   * Example:874   * <pre><code class='java'> public class Person {875   *   String name;876   *   List&lt;Person&gt; friends = new ArrayList&lt;&gt;();877   *   List&lt;Person&gt; enemies = new ArrayList&lt;&gt;();878   * }879   *880   * Person sherlock1 = new Person("Sherlock Holmes");881   * sherlock1.friends.add(new Person("Dr. John Watson"));882   * sherlock1.friends.add(new Person("Molly Hooper"));883   * sherlock1.enemies.add(new Person("Jim Moriarty"));884   * sherlock1.enemies.add(new Person("Irene Adler"));885   *886   * Person sherlock2 = new Person("Sherlock Holmes");887   * sherlock2.friends.add(new Person("Molly Hooper"));888   * sherlock2.friends.add(new Person("Dr. John Watson"));889   * sherlock2.enemies.add(new Person("Irene Adler"));890   * sherlock2.enemies.add(new Person("Jim Moriarty"));891   *892   * // assertion succeeds as friends and enemies fields collection order is ignored in the comparison893   * assertThat(sherlock1).usingRecursiveComparison()894   *                      .ignoringCollectionOrderInFieldsMatchingRegexes("friend.", "enemie.")895   *                      .isEqualTo(sherlock2);896   *897   * // assertion fails as enemies field collection order differ and it is not ignored898   * assertThat(sherlock1).usingRecursiveComparison()899   *                      .ignoringCollectionOrderInFields("friend.")900   *                      .isEqualTo(sherlock2);</code></pre>901   *902   * @param regexes regexes used to find the object under test fields to ignore collection order in the comparison.903   * @return this {@link RecursiveComparisonAssert} to chain other methods.904   */905  @CheckReturnValue906  public SELF ignoringCollectionOrderInFieldsMatchingRegexes(String... regexes) {907    recursiveComparisonConfiguration.ignoreCollectionOrderInFieldsMatchingRegexes(regexes);908    return myself;909  }910  /**911   * Makes the recursive comparison to check that actual's type is compatible with expected's type (and do the same for each field). <br>912   * Compatible means that the expected's type is the same or a subclass of actual's type.913   * <p>914   * Examples:915   * <pre><code class='java'> public class Person {916   *   String name;917   *   double height;918   *   Person bestFriend;919   * }920   *921   * Person sherlock = new Person("Sherlock", 1.80);922   * sherlock.bestFriend = new Person("Watson", 1.70);923   *924   * Person sherlockClone = new Person("Sherlock", 1.80);925   * sherlockClone.bestFriend = new Person("Watson", 1.70);926   *927   * // assertion succeeds as sherlock and sherlockClone have the same data and types928   * assertThat(sherlock).usingRecursiveComparison()929   *                     .withStrictTypeChecking()930   *                     .isEqualTo(sherlockClone);931   *932   * // Let's now define a data structure similar to Person933   *934   * public class PersonDTO {935   *   String name;936   *   double height;937   *   PersonDTO bestFriend;938   * }939   *940   * PersonDTO sherlockDto = new PersonDTO("Sherlock", 1.80);941   * sherlockDto.bestFriend = new PersonDTO("Watson", 1.70);942   *943   * // assertion fails as Person and PersonDTO are not compatible even though they have the same data944   * assertThat(sherlock).usingRecursiveComparison()945   *                     .withStrictTypeChecking()946   *                     .isEqualTo(noName);947   *948   * // Let's define a subclass of Person949   *950   * public class Detective extends Person {951   *   boolean busy;952   * }953   *954   * Detective detectiveSherlock = new Detective("Sherlock", 1.80);955   * detectiveSherlock.bestFriend = new Person("Watson", 1.70);956   * detectiveSherlock.busy = true;957   *958   * // assertion succeeds as Detective inherits from Person and959   * // only Person's fields are included into the comparison.960   * assertThat(sherlock).usingRecursiveComparison()961   *                     .withStrictTypeChecking()962   *                     .isEqualTo(detectiveSherlock);</code></pre>963   *964   * @return this {@link RecursiveComparisonAssert} to chain other methods.965   */966  @CheckReturnValue967  public SELF withStrictTypeChecking() {968    recursiveComparisonConfiguration.strictTypeChecking(true);969    return myself;970  }971  /**972   * Allows to register a {@link BiPredicate} to compare fields with the given locations.973   * A typical usage is for comparing double/float fields with a given precision.974   * <p>975   * BiPredicates specified with this method have precedence over the ones registered with {@link #withEqualsForType(BiPredicate, Class)}976   * or the comparators registered with {@link #withComparatorForType(Comparator, Class)}.977   * <p>978   * Note that registering a {@link BiPredicate} for a given field will override the previously registered Comparator (if any).979   * <p>980   * The field locations must be specified from the root object,981   * for example if {@code Foo} has a {@code Bar} field which has an {@code id}, one can register to a comparator for Bar's {@code id} by calling:982   * <pre><code class='java'> withEqualsForFields(idBiPredicate, "foo.id", "foo.bar.id")</code></pre>983   * <p>984   * Complete example:985   * <pre><code class='java'> public class TolkienCharacter {986   *   String name;987   *   double height;988   * }989   *990   * TolkienCharacter frodo = new TolkienCharacter(&quot;Frodo&quot;, 1.2);991   * TolkienCharacter tallerFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.3);992   * TolkienCharacter reallyTallFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.9);993   *994   * BiPredicate&lt;Double, Double&gt; closeEnough = (d1, d2) -&gt; Math.abs(d1 - d2) &lt;= 0.5;995   *996   * // assertion succeeds997   * assertThat(frodo).usingRecursiveComparison()998   *                  .withEqualsForFields(closeEnough, &quot;height&quot;)999   *                  .isEqualTo(tallerFrodo);1000   *1001   * // assertion fails1002   * assertThat(frodo).usingRecursiveComparison()1003   *                  .withEqualsForFields(closeEnough, &quot;height&quot;)1004   *                  .isEqualTo(reallyTallFrodo);</code></pre>1005   *1006   * @param equals the {@link BiPredicate} to use to compare the given fields1007   * @param fieldLocations the location from the root object of the fields the BiPredicate should be used for1008   *1009   * @return this {@link RecursiveComparisonAssert} to chain other methods.1010   * @throws NullPointerException if the given BiPredicate is null.1011   */1012  @CheckReturnValue1013  public SELF withEqualsForFields(BiPredicate<?, ?> equals, String... fieldLocations) {1014    recursiveComparisonConfiguration.registerEqualsForFields(equals, fieldLocations);1015    return myself;1016  }1017  /**1018   * Allows to register a comparator to compare fields with the given locations.1019   * A typical usage is for comparing double/float fields with a given precision.1020   * <p>1021   * Comparators registered with this method have precedence over comparators registered with {@link #withComparatorForType(Comparator, Class)}1022   * or {@link BiPredicate} registered with {@link #withEqualsForType(BiPredicate, Class)}.1023   * <p>1024   * The field locations must be specified from the root object,1025   * for example if {@code Foo} has a {@code Bar} field which has an {@code id}, one can register to a comparator for Bar's {@code id} by calling:1026   * <pre><code class='java'> withComparatorForFields(idComparator, "foo.id", "foo.bar.id")</code></pre>1027   * <p>1028   * Note that registering a {@link Comparator} for a given field will override the previously registered BiPredicate/Comparator (if any).1029   * <p>1030   * Complete example:1031   * <pre><code class='java'> public class TolkienCharacter {1032   *   String name;1033   *   double height;1034   * }1035   *1036   * TolkienCharacter frodo = new TolkienCharacter(&quot;Frodo&quot;, 1.2);1037   * TolkienCharacter tallerFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.3);1038   * TolkienCharacter reallyTallFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.9);1039   *1040   * Comparator&lt;Double&gt; closeEnough = (d1, d2) -&gt; Math.abs(d1 - d2) &lt;= 0.5 ? 0 : 1;1041   *1042   * // assertion succeeds1043   * assertThat(frodo).usingRecursiveComparison()1044   *                  .withComparatorForFields(closeEnough, &quot;height&quot;)1045   *                  .isEqualTo(tallerFrodo);1046   *1047   * // assertion fails1048   * assertThat(frodo).usingRecursiveComparison()1049   *                  .withComparatorForFields(closeEnough, &quot;height&quot;)1050   *                  .isEqualTo(reallyTallFrodo);</code></pre>1051   *1052   * @param comparator the {@link java.util.Comparator Comparator} to use to compare the given fields1053   * @param fieldLocations the location from the root object of the fields the comparator should be used for1054   * @return this {@link RecursiveComparisonAssert} to chain other methods.1055   * @throws NullPointerException if the given comparator is null.1056   */1057  @CheckReturnValue1058  public SELF withComparatorForFields(Comparator<?> comparator, String... fieldLocations) {1059    recursiveComparisonConfiguration.registerComparatorForFields(comparator, fieldLocations);1060    return myself;1061  }1062  /**1063   * Allows to register a comparator to compare the fields with the given type.1064   * A typical usage is for comparing double/float fields with a given precision.1065   * <p>1066   * Comparators registered with this method have less precedence than comparators registered with {@link #withComparatorForFields(Comparator, String...) withComparatorForFields(Comparator, String...)}1067   * or BiPredicate registered with {@link #withEqualsForFields(BiPredicate, String...) withEqualsForFields(BiPredicate, String...)}.1068   * <p>1069   * Note that registering a {@link Comparator} for a given type will override the previously registered BiPredicate/Comparator (if any).1070   * <p>1071   * Example:1072   * <pre><code class='java'> public class TolkienCharacter {1073   *   String name;1074   *   double height;1075   * }1076   *1077   * TolkienCharacter frodo = new TolkienCharacter(&quot;Frodo&quot;, 1.2);1078   * TolkienCharacter tallerFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.3);1079   * TolkienCharacter reallyTallFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.9);1080   *1081   * Comparator&lt;Double&gt; closeEnough = (d1, d2) -&gt; Math.abs(d1 - d2) &lt;= 0.5 ? 0 : 1;1082   *1083   * // assertion succeeds1084   * assertThat(frodo).usingRecursiveComparison()1085   *                  .withComparatorForType(closeEnough, Double.class)1086   *                  .isEqualTo(tallerFrodo);1087   *1088   * // assertion fails1089   * assertThat(frodo).usingRecursiveComparison()1090   *                  .withComparatorForType(closeEnough, Double.class)1091   *                  .isEqualTo(reallyTallFrodo);</code></pre>1092   *1093   * @param <T> the class type to register a comparator for1094   * @param comparator the {@link java.util.Comparator Comparator} to use to compare the given fields1095   * @param type the type to be compared with the given comparator.1096   *1097   * @return this {@link RecursiveComparisonAssert} to chain other methods.1098   * @throws NullPointerException if the given comparator is null.1099   */1100  @CheckReturnValue1101  public <T> SELF withComparatorForType(Comparator<? super T> comparator, Class<T> type) {1102    recursiveComparisonConfiguration.registerComparatorForType(comparator, type);1103    return myself;1104  }1105  /**1106   * Allows to register a {@link BiPredicate} to compare the fields with the given type.1107   * A typical usage is for comparing double/float fields with a given precision.1108   * <p>1109   * BiPredicates registered with this method have less precedence than the one registered  with {@link #withEqualsForFields(BiPredicate, String...) withEqualsForFields(BiPredicate, String...)}1110   * or comparators registered with {@link #withComparatorForFields(Comparator, String...) withComparatorForFields(Comparator, String...)}.1111   * <p>1112   * Note that registering a {@link BiPredicate} for a given type will override the previously registered BiPredicate/Comparator (if any).1113   * <p>1114   * Example:1115   * <pre><code class='java'> public class TolkienCharacter {1116   *   String name;1117   *   double height;1118   * }1119   *1120   * TolkienCharacter frodo = new TolkienCharacter(&quot;Frodo&quot;, 1.2);1121   * TolkienCharacter tallerFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.3);1122   * TolkienCharacter reallyTallFrodo = new TolkienCharacter(&quot;Frodo&quot;, 1.9);1123   *1124   * BiPredicate&lt;Double, Double&gt; closeEnough = (d1, d2) -&gt; Math.abs(d1 - d2) &lt;= 0.5;1125   *1126   * // assertion succeeds1127   * assertThat(frodo).usingRecursiveComparison()1128   *                  .withEqualsForType(closeEnough, Double.class)1129   *                  .isEqualTo(tallerFrodo);1130   *1131   * // assertion fails1132   * assertThat(frodo).usingRecursiveComparison()1133   *                  .withEqualsForType(closeEnough, Double.class)1134   *                  .isEqualTo(reallyTallFrodo);</code></pre>1135   *1136   * @param <T> the class type to register a BiPredicate for1137   * @param equals the {@link BiPredicate} to use to compare the given fields1138   * @param type the type to be compared with the given comparator.1139   *1140   * @return this {@link RecursiveComparisonAssert} to chain other methods.1141   * @throws NullPointerException if the given BiPredicate is null.1142   */1143  @CheckReturnValue1144  public <T> SELF withEqualsForType(BiPredicate<? super T, ? super T> equals, Class<T> type) {1145    recursiveComparisonConfiguration.registerEqualsForType(equals, type);1146    return myself;1147  }1148  SELF withTypeComparators(TypeComparators typeComparators) {1149    Optional.ofNullable(typeComparators)1150            .map(TypeComparators::comparatorByTypes)1151            .ifPresent(comparatorByTypes -> comparatorByTypes.forEach(this::registerComparatorForType));1152    return myself;1153  }1154  @SuppressWarnings({ "unchecked", "rawtypes" })1155  private void registerComparatorForType(Entry<Class<?>, Comparator<?>> entry) {1156    withComparatorForType((Comparator) entry.getValue(), entry.getKey());1157  }1158  /**1159   * Returns the {@link RecursiveComparisonConfiguration} currently used.1160   *1161   * @return the {@link RecursiveComparisonConfiguration} currently used1162   */1163  public RecursiveComparisonConfiguration getRecursiveComparisonConfiguration() {1164    return recursiveComparisonConfiguration;1165  }1166  private List<ComparisonDifference> determineDifferencesWith(Object expected) {1167    return recursiveComparisonDifferenceCalculator.determineDifferences(actual, expected, recursiveComparisonConfiguration);1168  }1169}...

determineDifferencesWith

Using AI Code Generation

1import org.assertj.core.api.Assertions;2import org.assertj.core.api.RecursiveComparisonAssert;3import org.assertj.core.api.RecursiveComparisonConfiguration;4import org.assertj.core.api.RecursiveComparisonConfigurationBuilder;5import org.assertj.core.groups.Tuple;6import org.junit.jupiter.api.Test;7import java.util.List;8import static org.assertj.core.api.Assertions.assertThat;9public class RecursiveComparisonAssertTest {10    void test() {11        Person person = new Person("John", "Doe", 30);12        Person person2 = new Person("Jane", "Doe", 30);13        RecursiveComparisonConfiguration configuration = RecursiveComparisonConfiguration.builder()14                .withIgnoredFields("firstName")15                .build();16        RecursiveComparisonAssert recursiveComparisonAssert = assertThat(person).usingRecursiveComparison(configuration);17        List<Tuple> differences = recursiveComparisonAssert.determineDifferencesWith(person2);18        assertThat(differences).hasSize(1);19        assertThat(differences.get(0).get(0)).isEqualTo("firstName");20        assertThat(differences.get(0).get(1)).isEqualTo("John");21        assertThat(differences.get(0).get(2)).isEqualTo("Jane");22    }23    private static class Person {24        private String firstName;25        private String lastName;26        private int age;27        public Person(String firstName, String lastName, int age) {28            this.firstName = firstName;29            this.lastName = lastName;30            this.age = age;31        }32        public String getFirstName() {33            return firstName;34        }35        public void setFirstName(String firstName) {36            this.firstName = firstName;37        }38        public String getLastName() {39            return lastName;40        }41        public void setLastName(String lastName) {42            this.lastName = lastName;43        }44        public int getAge() {45            return age;46        }47        public void setAge(int age) {48            this.age = age;49        }50    }51}52org.assertj.core.api.RecursiveComparisonAssertTest > test() PASSED

determineDifferencesWith

Using AI Code Generation

1Person person1 = new Person("John", "Doe", 35);2Person person2 = new Person("John", "Doe", 35);3List<RecursiveComparisonDifference> differences = assertThat(person1)4    .usingRecursiveComparison()5    .determineDifferencesWith(person2);6differences.forEach(System.out::println);

determineDifferencesWith

Using AI Code Generation

1package com.baeldung.assertj.recursivecomparison;2import java.util.HashMap;3import java.util.Map;4import org.assertj.core.api.Assertions;5import org.junit.jupiter.api.Test;6public class RecursiveComparisonUnitTest {7    public void givenTwoMaps_whenCompareWithRecursiveComparison_thenDifferencesArePrinted() {8        Map<String, String> map1 = new HashMap<>();9        map1.put("key1", "value1");10        map1.put("key2", "value2");11        Map<String, String> map2 = new HashMap<>();12        map2.put("key1", "value1");13        map2.put("key2", "value3");14        Assertions.assertThat(map1)15          .usingRecursiveComparison()16          .ignoringAllOverriddenEquals()17          .determineDifferencesWith(Differs::differences)18          .isEqualTo(map2);19    }20}21package com.baeldung.assertj.recursivecomparison;22import java.util.List;23import org.assertj.core.api.RecursiveComparisonDifference;24public class Differs {25    public static List<RecursiveComparisonDifference> differences(List<RecursiveComparisonDifference> differences) {26        differences.forEach(diff -> System.out.println(diff));27        return differences;28    }29}30RecursiveComparisonDifference [path=address, actualValue={city=London, country=UK}, expectedValue={city=London, country=England}]

determineDifferencesWith

Using AI Code Generation

1import static org.assertj.core.api.Assertions.assertThat;2public class Person {3    private String firstName;4    private String lastName;5    private Address address;6    public Person(String firstName, String lastName, Address address) {7        this.firstName = firstName;8        this.lastName = lastName;9        this.address = address;10    }11    public String getFirstName() {12        return firstName;13    }14    public String getLastName() {15        return lastName;16    }17    public Address getAddress() {18        return address;19    }20}21public class Address {22    private String streetName;23    private String streetNumber;24    public Address(String streetName, String streetNumber) {25        this.streetName = streetName;26        this.streetNumber = streetNumber;27    }28    public String getStreetName() {29        return streetName;30    }31    public String getStreetNumber() {32        return streetNumber;33    }34}35public class RecursiveComparisonAssertTest {36    public static void main(String[] args) {37        Person person1 = new Person("John", "Doe", new Address("Main Street", "1"));38        Person person2 = new Person("Jane", "Doe", new Address("Main Street", "1"));39        assertThat(person1)40                .usingRecursiveComparison()41                .ignoringFields("firstName", "lastName")42                .isEqualTo(person2);43    }44}

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.