How to use usingRecursiveFieldByFieldElementComparatorIgnoringFields method of org.assertj.core.api.AtomicReferenceArrayAssert class
Best Assertj code snippet using org.assertj.core.api.AtomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields
Source:AtomicReferenceArrayAssert.java 
...2322 * @since 2.7.0 / 3.7.02323 * @see #usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)2324 * @see <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2325 * @deprecated This method is deprecated because it performs a <b>shallow</b> field by field comparison, i.e. elements are2326 * compared field by field but the fields are compared with equals, use {@link #usingRecursiveFieldByFieldElementComparatorIgnoringFields(String...)} instead.2327 * <br>See <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2328 */2329 @Deprecated2330 @CheckReturnValue2331 public AtomicReferenceArrayAssert<T> usingElementComparatorIgnoringFields(String... fields) {2332 return usingExtendedByTypesElementComparator(new IgnoringFieldsComparator(comparatorsForElementPropertyOrFieldNames,2333 getComparatorsForElementPropertyOrFieldTypes(),2334 fields));2335 }2336 /**2337 * The assertions chained after this method will use a recursive field by field comparison on all fields (including inherited2338 * fields) <b>except</b> the given ones instead of relying on the element <code>equals</code> method.2339 * This is handy when the element <code>equals</code> method is not overridden or implemented as you expect.2340 * <p>2341 * Nested fields are supported and are expressed like: {@code name.first}2342 * <p>2343 * The comparison is <b>recursive</b>: elements are compared field by field, if a field type has fields they are also compared2344 * field by field (and so on).2345 * <p>2346 * Example:2347 * <pre><code class='java'> Player derrickRose = new Player(new Name("Derrick", "Rose"), "Chicago Bulls");2348 * derrickRose.nickname = new Name("Crazy", "Dunks");2349 *2350 * Player jalenRose = new Player(new Name("Jalen", "Rose"), "Chicago Bulls");2351 * jalenRose.nickname = new Name("Crazy", "Defense");2352 *2353 * // assertion succeeds2354 * assertThat(atomicArray(derrickRose)).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name.first", "nickname.last")2355 * .contains(jalenRose);2356 *2357 * // assertion fails, names are ignored but nicknames are not and nickname.last values differ2358 * assertThat(atomicArray(derrickRose)).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name")2359 * .contains(jalenRose);</code></pre>2360 * <p>2361 * This method is actually a shortcut of {@link #usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)}2362 * with a configuration ignoring the given fields, the previous example can be written as:2363 * <pre><code class='java'> RecursiveComparisonConfiguration configuration = RecursiveComparisonConfiguration.builder()2364 * .withIgnoredFields("name.first", "nickname.last")2365 * .build();2366 *2367 * assertThat(atomicArray(derrickRose)).usingRecursiveFieldByFieldElementComparator(configuration)2368 * .contains(jalenRose);</code></pre>2369 * 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>2370 * <p>2371 * @param fields the field names to exclude in the elements comparison.2372 * @return {@code this} assertion object.2373 * @since 3.20.02374 * @see #usingRecursiveFieldByFieldElementComparator(RecursiveComparisonConfiguration)2375 * @see <a href="https://assertj.github.io/doc/#assertj-core-recursive-comparison">https://assertj.github.io/doc/#assertj-core-recursive-comparison</a>2376 */2377 @CheckReturnValue2378 public AtomicReferenceArrayAssert<T> usingRecursiveFieldByFieldElementComparatorIgnoringFields(String... fields) {2379 RecursiveComparisonConfiguration recursiveComparisonConfiguration = RecursiveComparisonConfiguration.builder()2380 .withIgnoredFields(fields)2381 .build();2382 return usingRecursiveFieldByFieldElementComparator(recursiveComparisonConfiguration);2383 }2384 /**2385 * Extract the values of given field or property from the array's elements under test into a new array, this new array2386 * becoming the array under test.2387 * <p>2388 * It allows you to test a field/property of the array's elements instead of testing the elements themselves, which can2389 * be much less work !2390 * <p>2391 * Let's take an example to make things clearer :2392 * <pre><code class='java'> // Build a array of TolkienCharacter, a TolkienCharacter has a name (String) and a Race (a class)...
Source:AtomicReferenceArrayAssert_usingRecursiveFieldByFieldElementComparatorIgnoringFields_Test.java
...23import org.assertj.core.test.Name;24import org.assertj.core.test.Player;25import org.junit.jupiter.api.BeforeEach;26import org.junit.jupiter.api.Test;27class AtomicReferenceArrayAssert_usingRecursiveFieldByFieldElementComparatorIgnoringFields_Test28 extends AtomicReferenceArrayAssertBaseTest {29 private ObjectArrays arraysBefore;30 @BeforeEach31 void before() {32 arraysBefore = getArrays(assertions);33 }34 @Override35 protected AtomicReferenceArrayAssert<Object> invoke_api_method() {36 return assertions.usingRecursiveFieldByFieldElementComparatorIgnoringFields("field");37 }38 @Override39 protected void verify_internal_effects() {40 then(arraysBefore).isNotSameAs(getArrays(assertions));41 then(getArrays(assertions).getComparisonStrategy()).isInstanceOf(ComparatorBasedComparisonStrategy.class);42 then(getObjects(assertions).getComparisonStrategy()).isInstanceOf(AtomicReferenceArrayElementComparisonStrategy.class);43 RecursiveComparisonConfiguration recursiveComparisonConfiguration = RecursiveComparisonConfiguration.builder()44 .withIgnoredFields("field")45 .build();46 ConfigurableRecursiveFieldByFieldComparator expectedComparator = new ConfigurableRecursiveFieldByFieldComparator(recursiveComparisonConfiguration);47 then(getArrays(assertions).getComparator()).isEqualTo(expectedComparator);48 then(getObjects(assertions).getComparisonStrategy()).extracting("elementComparator").isEqualTo(expectedComparator);49 }50 @Test51 void should_ignore_given_fields_recursively() {52 // GIVEN53 Player rose = new Player(new Name("Derrick", "Rose"), "Chicago Bulls");54 rose.nickname = new Name("Crazy", "Dunks");55 Player jalen = new Player(new Name("Jalen", "Rose"), "Chicago Bulls");56 jalen.nickname = new Name("Crazy", "Defense");57 // WHEN/THEN58 then(list(rose)).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name.first", "nickname.last")59 .contains(jalen);60 }61}...
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1AtomicReferenceArrayAssert atomicReferenceArrayAssert = new AtomicReferenceArrayAssert(new AtomicReferenceArray(2));2atomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields("name");3AbstractAssert abstractAssert = new AbstractAssert(new Object(), ObjectAssert.class);4abstractAssert.usingRecursiveComparison();5AbstractAssert abstractAssert = new AbstractAssert(new Object(), ObjectAssert.class);6abstractAssert.usingComparatorForFields(new Comparator(), "name");7AbstractAssert abstractAssert = new AbstractAssert(new Object(), ObjectAssert.class);8abstractAssert.usingComparatorForElementFieldsWithType(new Comparator(), Object.class);9AbstractAssert abstractAssert = new AbstractAssert(new Object(), ObjectAssert.class);10abstractAssert.usingComparatorForElementPropertyOrFieldNames(new Comparator(), "name");11AbstractAssert abstractAssert = new AbstractAssert(new Object(), ObjectAssert.class);12abstractAssert.usingComparatorForElementPropertyOrFieldTypes(new Comparator(), Object.class);13AbstractAssert abstractAssert = new AbstractAssert(new Object(), ObjectAssert.class);14abstractAssert.usingComparatorForElementProperties(new Comparator(), "name");15AbstractAssert abstractAssert = new AbstractAssert(new Object(), ObjectAssert.class);16abstractAssert.usingComparatorForType(new Comparator(), Object.class);17AbstractAssert abstractAssert = new AbstractAssert(new Object(), ObjectAssert.class);18abstractAssert.usingElementComparator(new Comparator());
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1import org.assertj.core.api.Assertions;2import org.junit.jupiter.api.Test;3import java.util.concurrent.atomic.AtomicReferenceArray;4public class UsingRecursiveFieldByFieldElementComparatorIgnoringFields {5 public void testUsingRecursiveFieldByFieldElementComparatorIgnoringFields() {6 AtomicReferenceArray<String> atomicReferenceArray1 = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});7 AtomicReferenceArray<String> atomicReferenceArray2 = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});8 Assertions.assertThat(atomicReferenceArray1).usingRecursiveFieldByFieldElementComparator().ignoringFields("a").isEqualTo(atomicReferenceArray2);9 }10}
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class AtomicReferenceArrayAssert_usingRecursiveFieldByFieldElementComparatorIgnoringFields {2 public static void main(String[] args) {3 AtomicReferenceArray<String> actual = new AtomicReferenceArray<String>(new String[] {"foo", "bar"});4 AtomicReferenceArray<String> other = new AtomicReferenceArray<String>(new String[] {"foo", "bar"});5 assertThat(actual).usingRecursiveFieldByFieldElementComparatorIgnoringFields("foo").isEqualTo(other);6 }7}8when recursively comparing field by field, but found the following difference(s):9at org.assertj.core.api.AtomicReferenceArrayAssert_usingRecursiveFieldByFieldElementComparatorIgnoringFields.main(AtomicReferenceArrayAssert_usingRecursiveFieldByFieldElementComparatorIgnoringFields.java:10)
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1AtomicReferenceArrayAssert<String> atomicReferenceArrayAssert = new AtomicReferenceArrayAssert<>(new AtomicReferenceArray<>(new String[] { "a" }));2AtomicReferenceArrayAssert<String> atomicReferenceArrayAssert2 = new AtomicReferenceArrayAssert<>(new AtomicReferenceArray<>(new String[] { "a" }));3atomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields("a").isEqualTo(atomicReferenceArrayAssert2);4ObjectArrayAssert<String> objectArrayAssert = new ObjectArrayAssert<>(new String[] { "a" });5ObjectArrayAssert<String> objectArrayAssert2 = new ObjectArrayAssert<>(new String[] { "a" });6objectArrayAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields("a").isEqualTo(objectArrayAssert2);7ListAssert<String> listAssert = new ListAssert<>(new ArrayList<String>());8ListAssert<String> listAssert2 = new ListAssert<>(new ArrayList<String>());9listAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields("a").isEqualTo(listAssert2);10IterableAssert<String> iterableAssert = new IterableAssert<>(new ArrayList<String>());11IterableAssert<String> iterableAssert2 = new IterableAssert<>(new ArrayList<String>());12iterableAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields("a").isEqualTo(iterableAssert2);13AbstractIterableAssert<?, ?, String, ?> abstractIterableAssert = new AbstractIterableAssert<>(new ArrayList<String>(), AbstractIterableAssert.class);14AbstractIterableAssert<?, ?, String, ?> abstractIterableAssert2 = new AbstractIterableAssert<>(new ArrayList<String>(), AbstractIterableAssert.class);15abstractIterableAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields("a").isEqualTo(abstractIterableAssert2);
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class AssertjCore {2 public static void main(String[] args) {3 AtomicReferenceArray<String> array1 = new AtomicReferenceArray<>(new String[]{"foo", "bar"});4 AtomicReferenceArray<String> array2 = new AtomicReferenceArray<>(new String[]{"foo", "bar"});5 AtomicReferenceArrayAssert<String> atomicReferenceArrayAssert = new AtomicReferenceArrayAssert<>(array1);6 atomicReferenceArrayAssert.usingRecursiveFieldByFieldElementComparatorIgnoringFields("foo").isEqualTo(array2);7 }8}9Recommended Posts: AssertJ | UsingRecursiveComparison()10AssertJ | UsingComparatorForFields()11AssertJ | UsingComparatorForType()12AssertJ | UsingComparator()13AssertJ | UsingDefaultComparator()14AssertJ | UsingElementComparatorOnFields()15AssertJ | UsingElementComparatorOnPropertyOrField()16AssertJ | UsingComparatorOnFields()
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class AssertjCoreAtomicReferenceArrayAssertUsingRecursiveFieldByFieldElementComparatorIgnoringFields {2 public static void main(String[] args) {3 AtomicReferenceArray<String> actual = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});4 AtomicReferenceArray<String> expected = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});5 assertThat(actual).usingRecursiveFieldByFieldElementComparator().ignoringFields("a").isEqualTo(expected);6 }7}8when recursively comparing field by field, but found the following difference(s):
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class UsingRecursiveFieldByFieldElementComparatorIgnoringFields {2 public static void main(String args[]) {3 AtomicReferenceArray<String> array1 = new AtomicReferenceArray<>(new String[] {"foo", "bar", "baz"});4 AtomicReferenceArray<String> array2 = new AtomicReferenceArray<>(new String[] {"foo", "bar", "baz"});5 assertThat(array1).usingRecursiveFieldByFieldElementComparatorIgnoringFields("foo").isEqualTo(array2);6 }7}8public class UsingRecursiveFieldByFieldElementComparatorIgnoringFields {9 public static void main(String args[]) {10 AtomicReferenceArray<String> array1 = new AtomicReferenceArray<>(new String[] {"foo", "bar", "baz"});11 AtomicReferenceArray<String> array2 = new AtomicReferenceArray<>(new String[] {"foo", "bar", "baz"});12 assertThat(array1).usingRecursiveFieldByFieldElementComparatorIgnoringFields("foo", "bar").isEqualTo(array2);13 }14}
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1public class AtomicReferenceArrayAssert_usingRecursiveFieldByFieldElementComparatorIgnoringFields_Test {2 public void test_usingRecursiveFieldByFieldElementComparatorIgnoringFields() {3 AtomicReferenceArray<String> actual = new AtomicReferenceArray<>(new String[] { "Yoda", "Luke" });4 assertThat(actual).usingRecursiveFieldByFieldElementComparatorIgnoringFields("name").containsExactly(new Person("Yoda"), new Person("Luke"));5 }6}
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1import org.junit.Test;2import static org.assertj.core.api.Assertions.assertThat;3public class AssertjTest {4 public void testAssertj() {5 AtomicReferenceArray<Integer> array1 = new AtomicReferenceArray<>(new Integer[] { 1, 2, 3 });6 AtomicReferenceArray<Integer> array2 = new AtomicReferenceArray<>(new Integer[] { 1, 2, 3 });7 assertThat(array1).usingRecursiveFieldByFieldElementComparatorIgnoringFields("value").isEqualTo(array2);8 }9}10when recursively comparing field by field, but found the following difference(s):
usingRecursiveFieldByFieldElementComparatorIgnoringFields
Using AI Code Generation
1import org.junit.Test;2import java.util.concurrent.atomic.AtomicReferenceArray;3import static org.assertj.core.api.Assertions.assertThat;4public class AssertJAtomicReferenceArrayTest {5public void testAtomicReferenceArray() {6AtomicReferenceArray<String> array1 = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});7AtomicReferenceArray<String> array2 = new AtomicReferenceArray<>(new String[]{"a", "b", "c"});8AtomicReferenceArray<String> array3 = new AtomicReferenceArray<>(new String[]{"a", "b", "d"});9assertThat(array1).usingRecursiveFieldByFieldElementComparator().isEqualTo(array2);10assertThat(array1).usingRecursiveFieldByFieldElementComparator().isNotEqualTo(array3);11}12}13Related posts: Java – AssertJ AtomicReferenceArrayAssert – usingRecursiveFieldByFieldElementComparatorIgnoringFields() Java – AssertJ AtomicReferenceArrayAssert – usingRecursiveComparison() Java – AssertJ AtomicReferenceArrayAssert – usingDefaultComparator() Java – AssertJ AtomicReferenceArrayAssert – usingElementComparatorOnFields() Java – AssertJ AtomicReferenceArrayAssert – usingComparatorForFields() Java – AssertJ AtomicReferenceArrayAssert – usingComparatorForType() Java – AssertJ AtomicReferenceArrayAssert – usingComparatorForElementFieldsWithType() Java – AssertJ AtomicReferenceArrayAssert – usingComparatorForElementFieldsWithNames() Java – AssertJ AtomicReferenceArrayAssert – usingComparatorForElementFields() Java – AssertJ AtomicReferenceArrayAssert – usingComparatorForElementPropertyOrField() Java – AssertJ AtomicReferenceArrayAssert – usingComparatorForElementPropertyOrFieldWithNames() Java – AssertJ AtomicReferenceArrayAssert – usingComparatorForElementPropertyOrFieldWithType() Java – AssertJ AtomicReferenceArrayAssert – usingFieldByFieldElementComparator() Java – AssertJ AtomicReferenceArrayAssert – usingFieldByFieldElementComparatorIgnoringFields() Java – AssertJ AtomicReferenceArrayAssert – usingDefaultElementComparator() Java
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 AtomicReferenceArrayAssert
- AtomicReferenceArrayAssert
- isNullOrEmpty
- isEmpty
- isNotEmpty
- hasArray
- hasOnlyOneElementSatisfying
- hasSize
- hasSizeGreaterThan
- hasSizeGreaterThanOrEqualTo
- hasSizeLessThan
- hasSizeLessThanOrEqualTo
- hasSizeBetween
- hasSameSizeAs
- contains
- containsForProxy
- containsOnly
- containsOnlyForProxy
- containsOnlyElementsOf
- containsOnlyNulls
- 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
- extract
- flatExtracting
- doFlatExtracting
- specification
- toString
- sayTheWords
- extractingResultOf
- inHexadecimal
- inBinary
- filteredOn
- filteredOnNull
- matches
- allMatch
- allSatisfy
- internalAllSatisfy
- anyMatch
- anySatisfy
- internalAnySatisfy
- noneSatisfy
- internalNoneSatisfy
- satisfiesExactly
- satisfiesExactlyForProxy
- satisfiesExactlyInAnyOrder
- satisfiesExactlyInAnyOrderForProxy
- satisfiesOnlyOnce
- satisfiesOnlyOnceForProxy
- containsAnyOf
- containsAnyOfForProxy
- containsAnyElementsOf
- noneMatch
- getComparatorsByType
- getComparatorsForElementPropertyOrFieldTypes
- internalFilteredOn
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
