KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta 
How to use ignoringActualEmptyOptionalFields method of org.assertj.core.api.RecursiveComparisonAssert class
Best Assertj code snippet using org.assertj.core.api.RecursiveComparisonAssert.ignoringActualEmptyOptionalFields
Source:RecursiveComparisonConfiguration.java 
...779 }780 /**781 * Sets whether actual empty optional fields are ignored in the recursive comparison.782 * <p>783 * See {@link RecursiveComparisonAssert#ignoringActualEmptyOptionalFields()} for code examples.784 *785 * @param ignoreAllActualEmptyOptionalFields whether to ignore actual empty optional fields in the recursive comparison786 * @return this builder.787 */788 public Builder withIgnoreAllActualEmptyOptionalFields(boolean ignoreAllActualEmptyOptionalFields) {789 this.ignoreAllActualEmptyOptionalFields = ignoreAllActualEmptyOptionalFields;790 return this;791 }792 /**793 * Sets whether expected null fields are ignored in the recursive comparison.794 * <p>795 * See {@link RecursiveComparisonAssert#ignoringExpectedNullFields()} for code examples.796 *797 * @param ignoreAllExpectedNullFields whether to ignore expected null fields in the recursive comparison...
Source:RecursiveComparisonAssert.java
...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 {...
ignoringActualEmptyOptionalFields
Using AI Code Generation
1package org.example;2import org.assertj.core.api.Assertions;3import org.assertj.core.api.RecursiveComparisonAssert;4import org.assertj.core.api.RecursiveComparisonConfiguration;5import java.util.Optional;6public class Main {7 public static void main(String[] args) {8 RecursiveComparisonConfiguration configuration = new RecursiveComparisonConfiguration();9 configuration.ignoreActualEmptyOptionalFields();10 RecursiveComparisonAssert recursiveComparisonAssert = Assertions.assertThat(new Person("John", 30, Optional.empty())).usingRecursiveComparison(configuration);11 recursiveComparisonAssert.isEqualTo(new Person("John", 30, Optional.of("New York")));12 }13}14package org.example;15import org.assertj.core.api.Assertions;16import org.assertj.core.api.RecursiveComparisonAssert;17import org.assertj.core.api.RecursiveComparisonConfiguration;18import java.util.Optional;19public class Main {20 public static void main(String[] args) {21 RecursiveComparisonConfiguration configuration = new RecursiveComparisonConfiguration();22 configuration.ignoreExpectedEmptyOptionalFields();23 RecursiveComparisonAssert recursiveComparisonAssert = Assertions.assertThat(new Person("John", 30, Optional.empty())).usingRecursiveComparison(configuration);24 recursiveComparisonAssert.isEqualTo(new Person("John", 30, Optional.of("New York")));25 }26}27package org.example;28import org.assertj.core.api.Assertions;29import org.assertj.core.api.RecursiveComparisonAssert;30import org.assertj.core.api.RecursiveComparisonConfiguration;31import java.util.Optional;32public class Main {33 public static void main(String[] args) {34 RecursiveComparisonConfiguration configuration = new RecursiveComparisonConfiguration();35 configuration.ignoreAllActualEmptyOptionalFields();36 RecursiveComparisonAssert recursiveComparisonAssert = Assertions.assertThat(new Person("John", 30, Optional.empty())).usingRecursiveComparison(configuration);37 recursiveComparisonAssert.isEqualTo(new Person("John", 30, Optional.of("New York")));38 }39}40package org.example;41import org.assertj.core.api.Assertions;42import org.assertj.core.api.RecursiveComparisonAssert;43import org.assertj.core.api.RecursiveComparisonConfiguration;44import java.util.Optional;45public class Main {46 public static void main(String[] args) {
ignoringActualEmptyOptionalFields
Using AI Code Generation
1package org.example;2import org.junit.jupiter.api.Test;3import java.util.Optional;4import static org.assertj.core.api.Assertions.assertThat;5class RecursiveComparisonAssertTest {6 void test() {7 Person person1 = new Person("John", "Doe", Optional.empty());8 Person person2 = new Person("John", "Doe", Optional.of("John Doe"));9 assertThat(person1).usingRecursiveComparison()10 .ignoringActualEmptyOptionalFields()11 .isEqualTo(person2);12 }13 static class Person {14 private final String firstName;15 private final String lastName;16 private final Optional<String> fullName;17 public Person(String firstName, String lastName, Optional<String> fullName) {18 this.firstName = firstName;19 this.lastName = lastName;20 this.fullName = fullName;21 }22 public String getFirstName() {23 return firstName;24 }25 public String getLastName() {26 return lastName;27 }28 public Optional<String> getFullName() {29 return fullName;30 }31 }32}33package org.example;34import org.junit.jupiter.api.Test;35import java.util.Optional;36import static org.assertj.core.api.Assertions.assertThat;37class RecursiveComparisonAssertTest {38 void test() {39 Person person1 = new Person("John", "Doe", Optional.empty());40 Person person2 = new Person("John", "Doe", Optional.of("John Doe"));41 assertThat(person1).usingRecursiveComparison()42 .ignoringExpectedEmptyOptionalFields()43 .isEqualTo(person2);44 }45 static class Person {46 private final String firstName;47 private final String lastName;48 private final Optional<String> fullName;49 public Person(String firstName, String lastName, Optional<String> fullName) {50 this.firstName = firstName;51 this.lastName = lastName;52 this.fullName = fullName;53 }54 public String getFirstName() {55 return firstName;56 }57 public String getLastName() {58 return lastName;59 }60 public Optional<String> getFullName() {61 return fullName;62 }63 }64}65package org.example;66import org.junit.jupiter.api.Test;67import java.util.Optional;68import static org.assertj.core.api.Assertions.assertThat;
ignoringActualEmptyOptionalFields
Using AI Code Generation
1import org.assertj.core.api.RecursiveComparisonAssert;2public class Test {3 public static void main(String[] args) {4 RecursiveComparisonAssert<RecursiveComparisonAssert> recursiveComparisonAssert = new RecursiveComparisonAssert<>(new Object());5 recursiveComparisonAssert.ignoringActualEmptyOptionalFields();6 }7}
ignoringActualEmptyOptionalFields
Using AI Code Generation
1import org.assertj.core.api.Assertions;2import org.assertj.core.api.RecursiveComparisonAssert;3import org.assertj.core.api.RecursiveComparisonConfiguration;4import org.assertj.core.data.Percentage;5import org.junit.Test;6import java.util.Optional;7import static org.assertj.core.api.Assertions.assertThat;8public class AssertJTest {9 public void test() {10 RecursiveComparisonConfiguration config = new RecursiveComparisonConfiguration();11 config.setIgnoredActualEmptyOptionalFields(true);12 RecursiveComparisonAssert<Optional> recursiveComparisonAssert = Assertions.assertThat(Optional.empty()).usingRecursiveComparison(config);13 assertThat(recursiveComparisonAssert).ignoringActualEmptyOptionalFields();14 }15}16at org.assertj.core.api.RecursiveComparisonAssert.isEqualTo(RecursiveComparisonAssert.java:194)17at org.assertj.core.api.RecursiveComparisonAssert.isEqualTo(RecursiveComparisonAssert.java:39)18at AssertJTest.test(AssertJTest.java:20)
ignoringActualEmptyOptionalFields
Using AI Code Generation
1import org.junit.jupiter.api.Test;2import org.junit.jupiter.api.BeforeEach;3import org.junit.jupiter.api.AfterEach;4import static org.assertj.core.api.Assertions.assertThat;5import static org.assertj.core.api.Assertions.assertThatExceptionOfType;6public class AssertJTest {7 private Person person1;8 private Person person2;9 public void setUp() {10 person1 = new Person("John", "Doe", 35);11 person2 = new Person("John", "Doe", 35);12 }13 public void tearDown() {14 person1 = null;15 person2 = null;16 }17 public void whenComparingTwoEqualObjects_thenNoException() {18 assertThat(person1).usingRecursiveComparison().ignoringActualEmptyOptionalFields()19 .isEqualTo(person2);20 }21 public void whenComparingTwoDifferentObjects_thenException() {22 person2.setAge(40);23 assertThatExceptionOfType(AssertionError.class)24 .isThrownBy(() -> assertThat(person1).usingRecursiveComparison()25 .ignoringActualEmptyOptionalFields().isEqualTo(person2))26 .withMessageContainingAll("age", "40", "35");27 }28}
ignoringActualEmptyOptionalFields
Using AI Code Generation
1public class RecursiveComparisonAssertIgnoringActualEmptyOptionalFields {2 public static void main(String[] args) {3 Optional<String> opt = Optional.empty();4 List<Optional> list = Arrays.asList(opt);5 List<Optional> list2 = Arrays.asList(Optional.of("A"));6 List<Optional> list3 = Arrays.asList(Optional.of("B"));7 List<Optional> list4 = Arrays.asList(Optional.of("C"));8 List<Optional> list5 = Arrays.asList(Optional.of("D"));9 List<Optional> list6 = Arrays.asList(Optional.of("E"));10 List<Optional> list7 = Arrays.asList(Optional.of("F"));11 List<Optional> list8 = Arrays.asList(Optional.of("G"));12 List<Optional> list9 = Arrays.asList(Optional.of("H"));13 List<Optional> list10 = Arrays.asList(Optional.of("I"));14 List<Optional> list11 = Arrays.asList(Optional.of("J"));15 List<Optional> list12 = Arrays.asList(Optional.of("K"));16 List<Optional> list13 = Arrays.asList(Optional.of("L"));17 List<Optional> list14 = Arrays.asList(Optional.of("M"));18 List<Optional> list15 = Arrays.asList(Optional.of("N"));19 List<Optional> list16 = Arrays.asList(Optional.of("O"));20 List<Optional> list17 = Arrays.asList(Optional.of("P"));21 List<Optional> list18 = Arrays.asList(Optional.of("Q"));22 List<Optional> list19 = Arrays.asList(Optional.of("R"));
ignoringActualEmptyOptionalFields
Using AI Code Generation
1public class RecursiveComparisonAssertIgnoringActualEmptyOptionalFields {2 public static void main(String[] args) {3 Person person = new Person("John", "Doe", 35);4 Person person1 = new Person("John", "Doe", 35);5 Person person2 = new Person("John", "Doe", 35);6 Person person3 = new Person("John", "Doe", 35);7 Person person4 = new Person("John", "Doe", 35);8 Person person5 = new Person("John", "Doe", 35);9 Person person6 = new Person("John", "Doe", 35);10 Person person7 = new Person("John", "Doe", 35);11 Person person8 = new Person("John", "Doe", 35);12 Person person9 = new Person("John", "Doe", 35);13 Person person10 = new Person("John", "Doe", 35);14 Person person11 = new Person("John", "Doe", 35);15 Person person12 = new Person("John", "Doe", 35);16 Person person13 = new Person("John", "Doe", 35);17 Person person14 = new Person("John", "Doe", 35);18 Person person15 = new Person("John", "Doe", 35);19 Person person16 = new Person("John", "Doe", 35);20 Person person17 = new Person("John", "Doe", 35);21 Person person18 = new Person("John", "Doe", 35);22 Person person19 = new Person("John", "Doe",
ignoringActualEmptyOptionalFields
Using AI Code Generation
1public class RecursiveComparisonAssertIgnoringActualEmptyOptionalFields {2 public static void main(String[] args) {3 List<Optional<String>> list = Arrays.asList(Optional.of("1"), Optional.empty(), Optional.of("2"));4 List<Optional<String>> list1 = Arrays.asList(Optional.of("1"), Optional.empty(), Optional.of("2"));5 Assertions.assertThat(list).usingRecursiveComparison().ignoringActualEmptyOptionalFields().isEqualTo(list1);6 }7}8when recursively comparing field by field, but found the following 1 difference(s):9public class RecursiveComparisonAssertIgnoringExpectedEmptyOptionalFields {10 public static void main(String[] args) {11 List<Optional<String>> list = Arrays.asList(Optional.of("1"), Optional.empty(), Optional.of("2"));12 List<Optional<String>> list1 = Arrays.asList(Optional.of("1"), Optional.empty(), Optional.of("2"));13 Assertions.assertThat(list).usingRecursiveComparison().ignoringExpectedEmptyOptionalFields().isEqualTo(list1);14 }15}16when recursively comparing field by field, but found the following 1 difference(s):
ignoringActualEmptyOptionalFields
Using AI Code Generation
1public class RecursiveComparisonAssertIgnoringActualEmptyOptionalFields {2 public static void main(String[] args) {3 Contact contact = new Contact();4 contact.setId(1);5 contact.setName("John");6 contact.setPhone("1234567890");7 contact.setAddress(null);8 contact.setNotes("Notes");9 Contact contact1 = new Contact();10 contact1.setId(1);11 contact1.setName("John");12 contact1.setPhone("1234567890");13 contact1.setAddress(null);14 contact1.setNotes(null);15 assertThat(contact).usingRecursiveComparison()16 .ignoringActualEmptyOptionalFields()17 .isEqualTo(contact1);18 }19}
ignoringActualEmptyOptionalFields
Using AI Code Generation
1import org.assertj.core.api.RecursiveComparisonAssert;2import org.assertj.core.api.Assertions;3class Main {4 public static void main(String[] args) {5 Person p = new Person("John", 30, new Address("London", 123));6 Person p1 = new Person("John", 30, new Address("London", 123));7 Assertions.assertThat(p).usingRecursiveComparison()8 .ignoringActualEmptyOptionalFields().isEqualTo(p1);9 }10}11class Person {12 private String name;13 private int age;14 private Address address;15 public Person(String name, int age, Address address) {16 this.name = name;17 this.age = age;18 this.address = address;19 }20 public String getName() {21 return name;22 }23 public int getAge() {24 return age;25 }26 public Address getAddress() {27 return address;28 }29}30class Address {31 private String city;32public class AssertJTest {33 private Person person1;34 private Person person2;35 public void setUp() {36 person1 = new Person("John", "Doe", 35);37 person2 = new Person("John", "Doe", 35);38 }39 public void tearDown() {40 person1 = null;41 person2 = null;42 }43 public void whenComparingTwoEqualObjects_thenNoException() {44 assertThat(person1).usingRecursiveComparison().ignoringActualEmptyOptionalFields()45 .isEqualTo(person2);46 }47 public void whenComparingTwoDifferentObjects_thenException() {48 person2.setAge(40);49 assertThatExceptionOfType(AssertionError.class)50 .isThrownBy(() -> assertThat(person1).usingRecursiveComparison()51 .ignoringActualEmptyOptionalFields().isEqualTo(person2))52 .withMessageContainingAll("age", "40", "35");53 }54}
ignoringActualEmptyOptionalFields
Using AI Code Generation
1public class RecursiveComparisonAssertIgnoringActualEmptyOptionalFields {2 public static void main(String[] args) {3 Optional<String> opt = Optional.empty();4 List<Optional> list = Arrays.asList(opt);5 List<Optional> list2 = Arrays.asList(Optional.of("A"));6 List<Optional> list3 = Arrays.asList(Optional.of("B"));7 List<Optional> list4 = Arrays.asList(Optional.of("C"));8 List<Optional> list5 = Arrays.asList(Optional.of("D"));9 List<Optional> list6 = Arrays.asList(Optional.of("E"));10 List<Optional> list7 = Arrays.asList(Optional.of("F"));11 List<Optional> list8 = Arrays.asList(Optional.of("G"));12 List<Optional> list9 = Arrays.asList(Optional.of("H"));13 List<Optional> list10 = Arrays.asList(Optional.of("I"));14 List<Optional> list11 = Arrays.asList(Optional.of("J"));15 List<Optional> list12 = Arrays.asList(Optional.of("K"));16 List<Optional> list13 = Arrays.asList(Optional.of("L"));17 List<Optional> list14 = Arrays.asList(Optional.of("M"));18 List<Optional> list15 = Arrays.asList(Optional.of("N"));19 List<Optional> list16 = Arrays.asList(Optional.of("O"));20 List<Optional> list17 = Arrays.asList(Optional.of("P"));21 List<Optional> list18 = Arrays.asList(Optional.of("Q"));22 List<Optional> list19 = Arrays.asList(Optional.of("R"));
ignoringActualEmptyOptionalFields
Using AI Code Generation
1public class RecursiveComparisonAssertIgnoringActualEmptyOptionalFields {2 public static void main(String[] args) {3 Contact contact = new Contact();4 contact.setId(1);5 contact.setName("John");6 contact.setPhone("1234567890");7 contact.setAddress(null);8 contact.setNotes("Notes");9 Contact contact1 = new Contact();10 contact1.setId(1);11 contact1.setName("John");12 contact1.setPhone("1234567890");13 contact1.setAddress(null);14 contact1.setNotes(null);15 assertThat(contact).usingRecursiveComparison()16 .ignoringActualEmptyOptionalFields()17 .isEqualTo(contact1);18 }19}
ignoringActualEmptyOptionalFields
Using AI Code Generation
1import org.assertj.core.api.RecursiveComparisonAssert;2import org.assertj.core.api.Assertions;3class Main {4 public static void main(String[] args) {5 Person p = new Person("John", 30, new Address("London", 123));6 Person p1 = new Person("John", 30, new Address("London", 123));7 Assertions.assertThat(p).usingRecursiveComparison()8 .ignoringActualEmptyOptionalFields().isEqualTo(p1);9 }10}11class Person {12 private String name;13 private int age;14 private Address address;15 public Person(String name, int age, Address address) {16 this.name = name;17 this.age = age;18 this.address = address;19 }20 public String getName() {21 return name;22 }23 public int getAge() {24 return age;25 }26 public Address getAddress() {27 return address;28 }29}30class Address {31 private String city;
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 RecursiveComparisonAssert
- RecursiveComparisonAssert
- isEqualTo
- isNotEqualTo
- comparingOnlyFields
- ignoringActualNullFields
- ignoringActualEmptyOptionalFields
- ignoringExpectedNullFields
- ignoringFields
- ignoringFieldsMatchingRegexes
- ignoringFieldsOfTypes
- equals
- ignoringAllOverriddenEquals
- usingOverriddenEquals
- ignoringOverriddenEqualsForFields
- ignoringOverriddenEqualsForTypes
- ignoringOverriddenEqualsForFieldsMatchingRegexes
- ignoringCollectionOrder
- ignoringCollectionOrderInFields
- ignoringCollectionOrderInFieldsMatchingRegexes
- withStrictTypeChecking
- withEqualsForFields
- withEqualsForFieldsMatchingRegexes
- withComparatorForFields
- withComparatorForType
- withEqualsForType
- withErrorMessageForFields
- withErrorMessageForType
- registerComparatorForType
- getRecursiveComparisonConfiguration
- determineDifferencesWith
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
