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 Github

copy

Full Screen

...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}...

Full Screen

Full Screen

determineDifferencesWith

Using AI Code Generation

copy

Full Screen

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

Full Screen

Full Screen

determineDifferencesWith

Using AI Code Generation

copy

Full Screen

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);

Full Screen

Full Screen

determineDifferencesWith

Using AI Code Generation

copy

Full Screen

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}]

Full Screen

Full Screen

determineDifferencesWith

Using AI Code Generation

copy

Full Screen

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}

Full Screen

Full Screen

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.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful