How to use usingRecursiveFieldByFieldElementComparatorIgnoringFields method of org.assertj.core.api.AbstractObjectArrayAssert class
Best Assertj code snippet using org.assertj.core.api.AbstractObjectArrayAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields
Source:AbstractObjectArrayAssert.java 
...2202 * @return {@code this} assertion object.2203 * @see #usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)2204 * @see <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2205 * @deprecated This method is deprecated because it performs a <b>shallow</b> field by field comparison, i.e. elements are2206 * compared field by field but the fields are compared with equals, use {@link #usingRecursiveFieldByFieldElementComparatorIgnoringFields(String...)} instead.2207 * <br>See <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2208 */2209 @Deprecated2210 @CheckReturnValue2211 public SELF usingElementComparatorIgnoringFields(String... fields) {2212 return usingExtendedByTypesElementComparator(new IgnoringFieldsComparator(comparatorsForElementPropertyOrFieldNames,2213 getComparatorsForElementPropertyOrFieldTypes(),2214 fields));2215 }2216 /**2217 * The assertions chained after this method will use a recursive field by field comparison on all fields (including inherited2218 * fields) <b>except</b> the given ones instead of relying on the element <code>equals</code> method.2219 * This is handy when the element <code>equals</code> method is not overridden or implemented as you expect.2220 * <p>2221 * Nested fields are supported and are expressed like: {@code name.first}2222 * <p>2223 * The comparison is <b>recursive</b>: elements are compared field by field, if a field type has fields they are also compared2224 * field by field (and so on).2225 * <p>2226 * Example:2227 * <pre><code class='java'> Player derrickRose = new Player(new Name("Derrick", "Rose"), "Chicago Bulls");2228 * derrickRose.nickname = new Name("Crazy", "Dunks");2229 *2230 * Player jalenRose = new Player(new Name("Jalen", "Rose"), "Chicago Bulls");2231 * jalenRose.nickname = new Name("Crazy", "Defense");2232 *2233 * // assertion succeeds2234 * assertThat(array(derrickRose)).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name.first", "nickname.last")2235 * .contains(jalenRose);2236 *2237 * // assertion fails, names are ignored but nicknames are not and nickname.last values differ2238 * assertThat(array(derrickRose)).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name")2239 * .contains(jalenRose);</code></pre>2240 * <p>2241 * This method is actually a shortcut of {@link #usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)}2242 * with a configuration ignoring the given fields, the previous example can be written as:2243 * <pre><code class='java'> RecursiveComparisonConfiguration configuration = RecursiveComparisonConfiguration.builder()2244 * .withIgnoredFields("name.first", "nickname.last")2245 * .build();2246 *2247 * assertThat(array(derrickRose)).usingRecursiveFieldByFieldElementComparator(configuration)2248 * .contains(jalenRose);</code></pre>2249 * The recursive comparison is documented here: <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2250 * <p>2251 * @param fields the field names to exclude in the elements comparison.2252 * @return {@code this} assertion object.2253 * @since 3.20.02254 * @see #usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)2255 * @see <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2256 */2257 @CheckReturnValue2258 public SELF usingRecursiveFieldByFieldElementComparatorIgnoringFields(String... fields) {2259 RecursiveComparisonConfiguration recursiveComparisonConfiguration = RecursiveComparisonConfiguration.builder()2260 .withIgnoredFields(fields)2261 .build();2262 return usingRecursiveFieldByFieldElementComparator(recursiveComparisonConfiguration);2263 }2264 /**2265 * Extract the values of given field or property from the array's elements under test into a new list, this new list2266 * becoming the object under test.2267 * <p>2268 * It allows you to test a field/property of the array's elements instead of testing the elements themselves, which can2269 * be much less work !2270 * <p>2271 * Let's take an example to make things clearer :2272 * <pre><code class='java'> // Build a array of TolkienCharacter, a TolkienCharacter has a name (String) and a Race (a class)...
Source:AbstractIterableAssert.java
...2612 * @return {@code this} assertion object.2613 * @see #usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)2614 * @see <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2615 * @deprecated This method is deprecated because it performs a <b>shallow</b> field by field comparison, i.e. elements are2616 * compared field by field but the fields are compared with equals, use {@link #usingRecursiveFieldByFieldElementComparatorIgnoringFields(String...)} instead.2617 * <br>See <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2618 */2619 @Deprecated2620 @CheckReturnValue2621 public SELF usingElementComparatorIgnoringFields(String... fields) {2622 return usingExtendedByTypesElementComparator(new IgnoringFieldsComparator(comparatorsForElementPropertyOrFieldNames,2623 getComparatorsForElementPropertyOrFieldTypes(),2624 fields));2625 }2626 /**2627 * The assertions chained after this method will use a recursive field by field comparison on all fields (including inherited2628 * fields) <b>except</b> the given ones instead of relying on the element <code>equals</code> method.2629 * This is handy when the element <code>equals</code> method is not overridden or implemented as you expect.2630 * <p>2631 * Nested fields are supported and are expressed like: {@code name.first}2632 * <p>2633 * The comparison is <b>recursive</b>: elements are compared field by field, if a field type has fields they are also compared2634 * field by field (and so on).2635 * <p>2636 * Example:2637 * <pre><code class='java'> Player derrickRose = new Player(new Name("Derrick", "Rose"), "Chicago Bulls");2638 * derrickRose.nickname = new Name("Crazy", "Dunks");2639 *2640 * Player jalenRose = new Player(new Name("Jalen", "Rose"), "Chicago Bulls");2641 * jalenRose.nickname = new Name("Crazy", "Defense");2642 *2643 * // assertion succeeds2644 * assertThat(list(derrickRose)).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name.first", "nickname.last")2645 * .contains(jalenRose);2646 *2647 * // assertion fails, names are ignored but nicknames are not and nickname.last values differ2648 * assertThat(list(derrickRose)).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name")2649 * .contains(jalenRose);</code></pre>2650 * <p>2651 * This method is actually a shortcut of {@link #usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)}2652 * with a configuration ignoring the given fields, the previous example can be written as:2653 * <pre><code class='java'> RecursiveComparisonConfiguration configuration = RecursiveComparisonConfiguration.builder()2654 * .withIgnoredFields("name.first", "nickname.last")2655 * .build();2656 *2657 * assertThat(list(derrickRose)).usingRecursiveFieldByFieldElementComparator(configuration)2658 * .contains(jalenRose);</code></pre>2659 * The recursive comparison is documented here: <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2660 * <p>2661 * @param fields the field names to exclude in the elements comparison.2662 * @return {@code this} assertion object.2663 * @since 3.20.02664 * @see #usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)2665 * @see <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2666 */2667 @CheckReturnValue2668 public SELF usingRecursiveFieldByFieldElementComparatorIgnoringFields(String... fields) {2669 RecursiveComparisonConfiguration recursiveComparisonConfiguration = RecursiveComparisonConfiguration.builder()2670 .withIgnoredFields(fields)2671 .build();2672 return usingRecursiveFieldByFieldElementComparator(recursiveComparisonConfiguration);2673 }2674 /**2675 * Enable hexadecimal representation of Iterable elements instead of standard representation in error messages.2676 * <p>2677 * It can be useful to better understand what the error was with a more meaningful error message.2678 * <p>2679 * Example2680 * <pre><code class='java'> final List<Byte> bytes = newArrayList((byte) 0x10, (byte) 0x20);</code></pre>2681 *2682 * With standard error message:...
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1package org.example;2import static org.assertj.core.api.Assertions.usingRecursiveFieldByFieldElementComparatorIgnoringFields;3import static org.assertj.core.api.Assertions.assertThat;4import static org.assertj.core.api.Assertions.assertThatExceptionOfType;5import static org.assertj.core.api.Assertions.catchThrowable;6import static org.assertj.core.api.Assertions.catchThrowableOfType;7import static org.ass
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1package org.example;2import static org.assertj.core.api.Assertions.assertThat;3import static org.assertj.core.api.Assertions.usingRecursiveFieldByFieldElementComparatorIgnoringFields;4import java.util.ArrayList;5import java.util.List;6import org.junit.jupiter.api.Test;7public class ExampleTest {8 public void testUsingRecursiveFieldByFieldElementComparatorIgnoringFields() {9 List<Example> list1 = new ArrayList<>();10 Example example1 = new Example();11 example1.setId(1);12 example1.setName("A");13 list1.add(example1);14 List<Example> list2 = new ArrayList<>();15 Example example2 = new Example();16 example2.setId(1);17 example2.setName("B");18 list2.add(example2);19 assertThat(list1).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name").isEqualTo(list2);20 }21}22package org.example;23public class Example {24 private int id;25 private String name;26 public int getId() {27 return id;28 }29 public void setId(int id) {30 this.id = id;31 }32 public String getName() {33 return name;34 }35 public void setName(String name) {36 this.name = name;37 }38}39 <[[Example(id=1, name=A)]]>40 <[[Example(id=1, name=B)]]>41at org.example.ExampleTest.testUsingRecursiveFieldByFieldElementComparatorIgnoringFields(ExampleTest.java:20)
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1package org.assertj.core.api.objectarray;2import java.util.ArrayList;3import java.util.List;4import org.assertj.core.api.AbstractObjectArrayAssert;5import org.assertj.core.api.ObjectArrayAssert;6import org.assertj.core.api.ObjectArrayAssertBaseTest;7import org.junit.Test;8import static org.mockito.Mockito.verify;9import static org.assertj.core.api.Assertions.*;10public class ObjectArrayAssert_usingRecursiveFieldByFieldElementComparatorIgnoringFields_Test extends ObjectArrayAssertBaseTest {11 public void invoke_api_like_user() {12 List<String> fieldsToIgnore = new ArrayList<>();
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class UsingRecursiveFieldByFieldElementComparatorIgnoringFields {2 public static void main(String[] args) {3 Person[] person1 = {new Person("John", "Doe"), new Person("Jane", "Doe")};4 Person[] person2 = {new Person("John", "Doe"), new Person("Jane", "Doe")};5 assertThat(person1).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name")6 .containsExactly(person2);7 }8}9public class Person {10 public String name;11 public String surname;12 public Person(String name, String surname) {13 this.name = name;14 this.surname = surname;15 }16}17Expected :[Person(name=John, surname=Doe), Person(name=Jane, surname=Doe)]18Actual :[Person(name=null, surname=Doe), Person(name=null, surname=Doe)]19package com.journaldev.junit;20import static org.assertj.core.api.Assertions.assertThat;21import org.junit.Test;22public class UsingRecursiveFieldByFieldElementComparatorIgnoringFields {23 public void testUsingRecursiveFieldByFieldElementComparatorIgnoringFields() {24 Person[] person1 = { new Person("John", "Doe"), new Person("Jane", "Doe") };25 Person[] person2 = { new Person("John", "Doe"), new Person("Jane", "Doe") };26 assertThat(person1).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name").containsExactly(person2);27 }28}29package com.journaldev.junit;30public class Person {31 public String name;32 public String surname;33 public Person(String name, String surname) {34 this.name = name;35 this.surname = surname;36 }37 public String toString() {38 return "Person [name=" + name + ", surname=" + surname + "]";39 }40}
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class AssertionUsingRecursiveFieldByFieldElementComparatorIgnoringFields {2 public static void main(String[] args) {3 Object[] array1 = {"one", "two", "three"};4 Object[] array2 = {"one", "two", "three"};5 Object[] array3 = {"one", "two", "three"};6 assertThat(array1).usingRecursiveFieldByFieldElementComparatorIgnoringFields("field1").containsExactly(array2, array3);7 }8}9to contain exactly (and in same order):10to contain exactly (and in same order):
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class UsingRecursiveFieldByFieldElementComparatorIgnoringFields {2 public static void main(String[] args) {3 Person[] persons = {new Person("John", 35), new Person("Jane", 35)};4 Person[] persons2 = {new Person("John", 35), new Person("Jane", 35)};5 assertThat(persons).usingRecursiveFieldByFieldElementComparatorIgnoringFields("age").containsExactly(persons2);6 }7}8public class Person {9 public String name;10 public int age;11 public Person(String name, int age) {12 this.name = name;13 this.age = age;14 }15}16Expected :[Person(name=John, age=35), Person(name=Jane, age=35)]17Actual :[Person(name=John, age=35), Person(name=Jane, age=0)]18package org.kodejava.example.assertj;19import org.junit.Test;20import static org.assertj.core.api.Assertions.assertThat;21public class UsingRecursiveFieldByFieldElementComparatorIgnoringFieldsTest {22 public void testUsingRecursiveFieldByFieldElementComparatorIgnoringFields() {23 Person[] persons = {new Person("John", 35), new Person("Jane", 35)};24 Person[] persons2 = {new Person("John", 35), new Person("Jane", 35)};25 assertThat(persons).usingRecursiveFieldByFieldElementComparatorIgnoringFields("age").containsExactly(persons2);26 }27}28package org.kodejava.example.assertj;29public class Person {30 public String name;31 public int age;32 public Person(String name, int age) {33 this.name = name;34 this.age = age;35 }36 public String toString() {37 return "Person{" +38 '}';39 }40}
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class UsingRecursiveFieldByFieldElementComparatorIgnoringFields {2 public static void main(String[] args) {3 Person[] persons = { new Person("John", 25), new Person("Jane", 26) };4 Person[] persons2 = { new Person("John", 25), new Person("Jane", 26) };5 assertThat(persons).usingRecursiveFieldByFieldElementComparatorIgnoringFields("age").isEqualTo(persons2);6 }7}8public class Person {9 private String name;10 private int age;11 public Person(String name, int age) {12 this.name = name;13 this.age = age;14 }15 public String getName() {16 return name;17 }18 public int getAge() {19 return age;20 }21}22 assertThat(persons).usingRecursiveFieldByFieldElementComparatorIgnoringFields("age").isEqualTo(persons2);
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1package org.example;2import java.util.Arrays;3import org.assertj.core.api.Assertions;4import org.junit.Test;5import static org.assertj.core.api.Assertions.*;6public class Example {7public void testUsingRecursiveFieldByFieldElementComparatorIgnoringFields() {8 Person[] persons = new Person[2];9 persons[0] = new Person("John", "Doe", 30);10 persons[1] = new Person("Jane", "Doe", 28);11 Person[] otherPersons = new Person[2];12 otherPersons[0] = new Person("John", "Doe", 30);13 otherPersons[1] = new Person("Jane", "Doe", 28);14 Assertions.assertThat(persons).usingRecursiveFieldByFieldElementComparatorIgnoringFields("age").isEqualTo(otherPersons);15}16}17class Person {18private String firstName;19private String lastName;20private int age;21public Person(String firstName, String lastName, int age) {22 this.firstName = firstName;23 this.lastName = lastName;24 this.age = age;25}26public String getFirstName() {27 return firstName;28}29public String getLastName() {30 return lastName;31}32public int getAge() {33 return age;34}35}
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class AssertjCoreExample {2 public static void main(String[] args) {3 ObjectArrayAssert<Object> objectArrayAssert = new ObjectArrayAssert<Object>(new Object[] { "a", "b", "c" });4 objectArrayAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields("field");5 }6}
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:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Assertj automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Most used method in AbstractObjectArrayAssert
- AbstractObjectArrayAssert
- isNullOrEmpty
- isEmpty
- isNotEmpty
- hasSize
- hasSizeGreaterThan
- hasSizeGreaterThanOrEqualTo
- hasSizeLessThan
- hasSizeLessThanOrEqualTo
- hasSizeBetween
- hasSameSizeAs
- contains
- containsForProxy
- containsOnly
- containsOnlyForProxy
- containsOnlyElementsOf
- containsOnlyNulls
- hasOnlyOneElementSatisfying
- hasSameElementsAs
- containsOnlyOnce
- containsOnlyOnceForProxy
- containsOnlyOnceElementsOf
- containsExactly
- containsExactlyForProxy
- containsExactlyInAnyOrder
- containsExactlyInAnyOrderForProxy
- containsExactlyInAnyOrderElementsOf
- containsExactlyElementsOf
- containsSequence
- containsSequenceForProxy
- doesNotContainSequence
- doesNotContainSequenceForProxy
- containsSubsequence
- containsSubsequenceForProxy
- doesNotContainSubsequence
- doesNotContainSubsequenceForProxy
- hasOnlyElementsOfTypes
- hasExactlyElementsOfTypes
- doesNotContain
- doesNotContainForProxy
- doesNotContainAnyElementsOf
- doesNotHaveDuplicates
- startsWith
- startsWithForProxy
- endsWith
- endsWithForProxy
- isSubsetOf
- isSubsetOfForProxy
- containsNull
- doesNotContainNull
- areNot
- have
- doNotHave
- areAtLeast
- areAtLeastOne
- areAtMost
- areExactly
- haveAtLeastOne
- haveAtLeast
- haveAtMost
- haveExactly
- hasAtLeastOneElementOfType
- hasOnlyElementsOfType
- doesNotHaveAnyElementsOfTypes
- isSorted
- isSortedAccordingTo
- containsAll
- usingElementComparator
- usingExtendedByTypesElementComparator
- usingDefaultElementComparator
- compare
- usingComparatorForElementFieldsWithNames
- usingComparatorForElementFieldsWithType
- usingComparatorForType
- usingFieldByFieldElementComparator
- usingRecursiveFieldByFieldElementComparator
- usingElementComparatorOnFields
- usingRecursiveFieldByFieldElementComparatorOnFields
- usingElementComparatorIgnoringFields
- usingRecursiveFieldByFieldElementComparatorIgnoringFields
- extracting
- extractingForProxy
- flatExtracting
- doFlatExtracting
- specification
- toString
- sayTheWords
- extractingResultOf
- inHexadecimal
- inBinary
- filteredOn
- filteredOnNull
- matches
- filteredOnAssertions
- internalFilteredOnAssertions
- allMatch
- allSatisfy
- internalAllSatisfy
- anyMatch
- zipSatisfy
- anySatisfy
- internalAnySatisfy
- noneSatisfy
- internalNoneSatisfy
- satisfiesExactly
- satisfiesExactlyForProxy
- satisfiesExactlyInAnyOrder
- satisfiesExactlyInAnyOrderForProxy
- satisfiesOnlyOnce
- satisfiesOnlyOnceForProxy
- containsAnyOf
- containsAnyOfForProxy
- containsAnyElementsOf
- noneMatch
- newListAssertInstance
- usingRecursiveComparison
- usingRecursiveAssertion
- singleElement
- internalSingleElement
- navigationDescription
- removeAssert
- toAssert
- getComparatorsByType
- getComparatorsForElementPropertyOrFieldTypes
- newObjectArrayAssert
- toGenericArray
- internalFilteredOn
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
