Join the 1-day Testing & QA Summit featuring 15+ Expert Speakers.Register for FREE! 
How to use usingRecursiveFieldByFieldElementComparatorIgnoringFields method of org.assertj.core.api.AbstractIterableAssert class
Best Assertj code snippet using org.assertj.core.api.AbstractIterableAssert.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
1import org.assertj.core.api.Assertions;2import org.junit.Test;3import java.util.ArrayList;4import java.util.List;5import static org.assertj.core.api.Assertions.usingRecursiveFieldByFieldElementComparatorIgnoringFields;6public class AssertJUsingRecursiveFieldByFieldElementComparatorIgnoringFields {7 public void usingRecursiveFieldByFieldElementComparatorIgnoringFieldsTest() {8 List<Employee> actual = new ArrayList<>();9 actual.add(new Employee("John", 25, "Developer"));10 actual.add(new Employee("John", 25, "Developer"));11 actual.add(new Employee("John", 25, "Developer"));12 List<Employee> expected = new ArrayList<>();13 expected.add(new Employee("John", 25, "Developer"));14 expected.add(new Employee("John", 25, "Developer"));15 expected.add(new Employee("John", 25, "Developer"));16 Assertions.assertThat(actual).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name").isEqualTo(expected);17 }18}19package org.assertj.core.api;20public class Employee {21 private String name;22 private int age;23 private String designation;24 public Employee(String name, int age, String designation) {25 this.name = name;26 this.age = age;27 this.designation = designation;28 }29 public String getName() {30 return name;31 }32 public void setName(String name) {33 this.name = name;34 }35 public int getAge() {36 return age;37 }38 public void setAge(int age) {39 this.age = age;40 }41 public String getDesignation() {42 return designation;43 }44 public void setDesignation(String designation) {45 this.designation = designation;46 }47}48when recursively comparing field by field, but found the following difference(s):
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1import org.assertj.core.api.AbstractIterableAssert;2import org.assertj.core.api.Assertions;3import org.assertj.core.internal.Objects;4import org.assertj.core.util.introspection.IntrospectionError;5import org.assertj.core.util.introspection.PropertyOrFieldSupport;6import org.junit.Test;7import java.util.ArrayList;8import java.util.List;9import java.util.logging.Logger;10public class AssertJTest {11 private static final Logger LOGGER = Logger.getLogger(AssertJTest.class.getName());12 public void testUsingRecursiveFieldByFieldElementComparatorIgnoringFields() {13 List<Employee> expected = new ArrayList<>();14 expected.add(new Employee("John", "Doe", 1000));15 expected.add(new Employee("Jane", "Doe", 2000));16 expected.add(new Employee("Jack", "Doe", 3000));17 List<Employee> actual = new ArrayList<>();18 actual.add(new Employee("John", "Doe", 1000));19 actual.add(new Employee("Jane", "Doe", 2000));20 actual.add(new Employee("Jack", "Doe", 3000));21 Assertions.assertThat(actual).usingRecursiveFieldByFieldElementComparatorIgnoringFields("salary").isEqualTo(expected);22 }23}24public class Employee {25 private String firstName;26 private String lastName;27 private int salary;28 public Employee(String firstName, String lastName, int salary) {29 this.firstName = firstName;30 this.lastName = lastName;31 this.salary = salary;32 }33 public String getFirstName() {34 return firstName;35 }36 public void setFirstName(String firstName) {37 this.firstName = firstName;38 }39 public String getLastName() {40 return lastName;41 }42 public void setLastName(String lastName) {43 this.lastName = lastName;44 }45 public int getSalary() {46 return salary;47 }48 public void setSalary(int salary) {49 this.salary = salary;50 }51}52 <[Employee(firstName=John, lastName=Doe, salary=1000), Employee(firstName=Jane, lastName=Doe, salary=2000), Employee(firstName=Jack, lastName=Doe, salary=3000)]>53 <[Employee(firstName=John, lastName=Doe
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1import org.junit.Test;2import static org.assertj.core.api.Assertions.assertThat;3public class AssertJTest {4 public void test() {5 assertThat(new String[] { "a", "b" }).usingRecursiveFieldByFieldElementComparatorIgnoringFields("b").contains(new String[] { "a", "b" });6 }7}8import org.junit.Test;9import static org.assertj.core.api.Assertions.assertThat;10public class AssertJTest {11 public void test() {12 assertThat(new String[] { "a", "b" }).usingRecursiveFieldByFieldElementComparatorIgnoringFields("a").contains(new String[] { "a", "b" });13 }14}15import org.junit.Test;16import static org.assertj.core.api.Assertions.assertThat;17public class AssertJTest {18 public void test() {19 assertThat(new String[] { "a", "b" }).usingRecursiveFieldByFieldElementComparatorIgnoringFields("a", "b").contains(new String[] { "a", "b" });20 }21}
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1package org.example;2import org.junit.Test;3import static org.assertj.core.api.Assertions.assertThat;4import java.util.ArrayList;5import java.util.Arrays;6import java.util.List;7{8 public void testUsingRecursiveFieldByFieldElementComparatorIgnoringFields()9 {10 List<Bean> beanList1 = new ArrayList<>();11 beanList1.add(new Bean("a", "b"));12 beanList1.add(new Bean("c", "d"));13 List<Bean> beanList2 = new ArrayList<>();14 beanList2.add(new Bean("a", "b"));15 beanList2.add(new Bean("c", "d"));16 assertThat(beanList1).usingRecursiveFieldByFieldElementComparatorIgnoringFields("field2").isEqualTo(beanList2);17 }18}19package org.example;20{21 private String field1;22 private String field2;23 public Bean(String field1, String field2)24 {25 this.field1 = field1;26 this.field2 = field2;27 }28 public String getField1()29 {30 return field1;31 }32 public void setField1(String field1)33 {34 this.field1 = field1;35 }36 public String getField2()37 {38 return field2;39 }40 public void setField2(String field2)41 {42 this.field2 = field2;43 }44}45when recursively comparing field by field, but found the following difference(s):46 at org.example.AppTest.testUsingRecursiveFieldByFieldElementComparatorIgnoringFields(AppTest.java:17)
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1import org.assertj.core.api.*;2import org.assertj.core.api.Assertions;3public class AssertJExample {4 public static void main(String[] args) {5 Person person1 = new Person("John", "Doe");6 Person person2 = new Person("John", "Doe");7 Person person3 = new Person("John", "Doe");8 Iterable<Person> iterable1 = Arrays.asList(person1, person2);9 Iterable<Person> iterable2 = Arrays.asList(person3, person2);10 Assertions.assertThat(iterable1).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name").isEqualTo(iterable2);11 }12}13import org.assertj.core.api.*;14import org.assertj.core.api.Assertions;15public class AssertJExample {16 public static void main(String[] args) {17 Person person1 = new Person("John", "Doe");18 Person person2 = new Person("John", "Doe");19 Person person3 = new Person("John", "Doe");20 Iterable<Person> iterable1 = Arrays.asList(person1, person2);21 Iterable<Person> iterable2 = Arrays.asList(person3, person2);22 Assertions.assertThat(iterable1).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name").isEqualTo(iterable2);23 }24}
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1import org.assertj.core.api.Assertions;2import org.assertj.core.api.AbstractIterableAssert;3import org.junit.Test;4public class AssertjTest {5 public void test() {6 Assertions.assertThat(new String[] { "a", "b", "c" }).usingRecursiveFieldByFieldElementComparatorIgnoringFields("a").containsExactly("a", "b", "c");7 }8}9import org.assertj.core.api.Assertions;10import org.assertj.core.api.AbstractIterableAssert;11import org.junit.Test;12public class AssertjTest {13 public void test() {14 Assertions.assertThat(new String[] { "a", "b", "c" }).usingRecursiveFieldByFieldElementComparator().containsExactly("a", "b", "c");15 }16}17import org.assertj.core.api.Assertions;18import org.assertj.core.api.AbstractIterableAssert;19import org.junit.Test;20public class AssertjTest {21 public void test() {
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class AssertJExample {2 public static void main(String[] args) {3 List<Developer> actualDevelopers = new ArrayList<>();4 actualDevelopers.add(new Developer("abc", 10, new ArrayList<>()));5 actualDevelopers.add(new Developer("xyz", 20, new ArrayList<>()));6 actualDevelopers.add(new Developer("pqr", 30, new ArrayList<>()));7 List<Developer> expectedDevelopers = new ArrayList<>();8 expectedDevelopers.add(new Developer("abc", 10, new ArrayList<>()));9 expectedDevelopers.add(new Developer("xyz", 20, new ArrayList<>()));10 expectedDevelopers.add(new Developer("pqr", 30, new ArrayList<>()));11 Assertions.assertThat(actualDevelopers).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name","age").containsAll(expectedDevelopers);12 }13}14 <[Developer(name=abc, age=10, skills=[]), Developer(name=xyz, age=20, skills=[]), Developer(name=pqr, age=30, skills=[])])>15 <[Developer(name=abc, age=10, skills=[]), Developer(name=xyz, age=20, skills=[]), Developer(name=pqr, age=30, skills=[])])>16 <[Developer(name=abc, age=10, skills=[]), Developer(name=xyz, age=20, skills=[]), Developer(name=pqr, age=30, skills=[])])>
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 AbstractIterableAssert
- AbstractIterableAssert
- isNullOrEmpty
- isEmpty
- isNotEmpty
- hasSize
- hasSizeGreaterThan
- hasSizeGreaterThanOrEqualTo
- hasSizeLessThan
- hasSizeLessThanOrEqualTo
- hasSizeBetween
- hasOnlyOneElementSatisfying
- hasSameSizeAs
- contains
- containsForProxy
- containsOnly
- containsOnlyForProxy
- containsOnlyOnce
- containsOnlyOnceForProxy
- containsOnlyNulls
- containsExactly
- containsExactlyForProxy
- containsExactlyInAnyOrder
- containsExactlyInAnyOrderForProxy
- containsExactlyInAnyOrderElementsOf
- isSubsetOf
- isSubsetOfForProxy
- containsSequence
- containsSequenceForProxy
- doesNotContainSequence
- doesNotContainSequenceForProxy
- containsSubsequence
- containsSubsequenceForProxy
- doesNotContainSubsequence
- doesNotContainSubsequenceForProxy
- doesNotContain
- doesNotContainForProxy
- doesNotContainAnyElementsOf
- doesNotHaveDuplicates
- startsWith
- startsWithForProxy
- endsWith
- endsWithForProxy
- containsNull
- doesNotContainNull
- areNot
- have
- doNotHave
- areAtLeastOne
- areAtLeast
- areAtMost
- areExactly
- haveAtLeastOne
- haveAtLeast
- haveAtMost
- haveExactly
- hasAtLeastOneElementOfType
- hasOnlyElementsOfType
- doesNotHaveAnyElementsOfTypes
- hasOnlyElementsOfTypes
- hasExactlyElementsOfTypes
- containsAll
- usingElementComparator
- usingExtendedByTypesElementComparator
- usingDefaultElementComparator
- containsAnyOf
- containsAnyOfForProxy
- containsAnyElementsOf
- extracting
- specification
- toString
- sayTheWords
- extractingResultOf
- internalExtracting
- newListAssertInstanceForMethodsChangingElementType
- flatExtracting
- flatMap
- doFlatExtracting
- flatExtractingForProxy
- extractingForProxy
- containsExactlyElementsOf
- containsOnlyElementsOf
- containsOnlyOnceElementsOf
- hasSameElementsAs
- compare
- usingComparatorForElementFieldsWithNames
- usingComparatorForElementFieldsWithType
- usingComparatorForType
- usingFieldByFieldElementComparator
- usingRecursiveFieldByFieldElementComparator
- usingRecursiveComparison
- usingRecursiveAssertion
- usingElementComparatorOnFields
- usingRecursiveFieldByFieldElementComparatorOnFields
- usingComparisonStrategy
- usingElementComparatorIgnoringFields
- usingRecursiveFieldByFieldElementComparatorIgnoringFields
- inHexadecimal
- inBinary
- filteredOn
- filteredOnNull
- matches
- filteredOnAssertions
- internalFilteredOnAssertions
- first
- internalFirst
- last
- internalLast
- lastElement
- element
- elements
- newAbstractIterableAssertForProxy
- assertIndicesIsNotNull
- assertIndicesIsNotEmpty
- checkIndexValidity
- internalElement
- singleElement
- internalSingleElement
- toAssert
- navigationDescription
- removeAssert
- allMatch
- allSatisfy
- internalAllSatisfy
- anyMatch
- zipSatisfy
- anySatisfy
- internalAnySatisfy
- noneSatisfy
- internalNoneSatisfy
- satisfiesExactly
- satisfiesExactlyForProxy
- satisfiesExactlyInAnyOrder
- satisfiesExactlyInAnyOrderForProxy
- satisfiesOnlyOnce
- satisfiesOnlyOnceForProxy
- describedAs
- doesNotHave
- doesNotHaveSameClassAs
- hasSameClassAs
- hasToString
- isEqualTo
- isExactlyInstanceOf
- isIn
- isInstanceOf
- isInstanceOfAny
- isNot
- isNotEqualTo
- isNotExactlyInstanceOf
- isNotIn
- isNotInstanceOf
- isNotInstanceOfAny
- isNotOfAnyClassIn
- isNotNull
- isNotSameAs
- isOfAnyClassIn
- isSameAs
- noneMatch
- overridingErrorMessage
- usingDefaultComparator
- usingComparator
- withFailMessage
- withThreadDumpOnError
- size
- getComparatorsByType
- getComparatorsForElementPropertyOrFieldTypes
- newAbstractIterableAssert
- internalFilteredOn
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
