How to use ignoringFieldsOfTypes method of org.assertj.core.api.RecursiveAssertionAssert class

Best Assertj code snippet using org.assertj.core.api.RecursiveAssertionAssert.ignoringFieldsOfTypes

Source:AbstractObjectAssert.java

...143   * @deprecated Use the recursive comparison by calling {@link #usingRecursiveComparison()} and specify the fields to ignore.144   * <p>145   * <b>Warning:</b> the recursive comparison does not provide a strictly equivalent feature, instead it provides several ways to ignore146   * fields in the comparison {@link RecursiveComparisonAssert#ignoringFields(String...) by specifying fields to ignore}, or147   * {@link RecursiveComparisonAssert#ignoringFieldsOfTypes(Class...) fields by type} or148   * {@link RecursiveComparisonAssert#ignoringFieldsMatchingRegexes(String...) fields matching regexes}. The idea being that it is best149   * to compare as many fields as possible and only ignore the ones that are not relevant (for example generated ids).150   * <p>151   * This method is deprecated because it only compares the first level of fields while the recursive comparison traverses all152   * fields recursively (only stopping at java types).153   * <p>154   * For example suppose actual and expected are of type A which has the following structure:155   * <pre><code class="text"> A156   * |â B b157   * |    |â String s158   * |    |â C c159   * |         |â String s160   * |         |â Date d161   * |â int i</code></pre>162   * {@code isEqualToComparingOnlyGivenFields} will compare actual and expected {@code A.b} and {@code A.i} fields but not B fields163   * (it calls B equals method instead comparing B fields).<br>164   * The recursive comparison on the other hand will introspect B fields and then C fields and will compare actual and expected165   * respective fields values, that is: {@code A.i}, {@code A.B.s}, {@code A.B.C.s} and {@code A.B.C.d}.166   * <p>167   * Assuming actual has 4 fields f1, f2, f3, f4, instead of writing:168   * <pre><code class='java'> assertThat(actual).isEqualToComparingOnlyGivenFields(expected, f1, f2);</code></pre>169   * You should write:170   * <pre><code class='java'> assertThat(actual).usingRecursiveComparison()171   *                   .ignoringFields(f3, f4)172   *                   .isEqualTo(expected);</code></pre>173   * <b>Original javadoc</b>174   * <p>175   * Asserts that the actual object is equal to the given one using a property/field by property/field comparison <b>on the given properties/fields only</b>176   * (fields can be inherited fields or nested fields). This can be handy if {@code equals} implementation of objects to compare does not suit you.177   * <p>178   * Note that comparison is <b>not</b> recursive, if one of the field is an Object, it will be compared to the other179   * field using its {@code equals} method.180   * <p>181   * If an object has a field and a property with the same name, the property value will be used over the  field.182   * <p>183   * Private fields are used in comparison but this can be disabled using184   * {@link Assertions#setAllowComparingPrivateFields(boolean)}, if disabled only <b>accessible </b>fields values are185   * compared, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter.186   * <p>187   * The objects to compare can be of different types but the properties/fields used in comparison must exist in both,188   * for example if actual object has a name String field, it is expected the other object to also have one.189   * <p>190   *191   * Example:192   * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter(&quot;Frodo&quot;, 33, HOBBIT);193   * TolkienCharacter sam = new TolkienCharacter(&quot;Sam&quot;, 38, HOBBIT);194   *195   * // frodo and sam both are hobbits, so they are equals when comparing only race196   * assertThat(frodo).isEqualToComparingOnlyGivenFields(sam, &quot;race&quot;); // OK197   *198   * // they are also equals when comparing only race name (nested field).199   * assertThat(frodo).isEqualToComparingOnlyGivenFields(sam, &quot;race.name&quot;); // OK200   *201   * // ... but not when comparing both name and race202   * assertThat(frodo).isEqualToComparingOnlyGivenFields(sam, &quot;name&quot;, &quot;race&quot;); // FAIL</code></pre>203   *204   * @param other the object to compare {@code actual} to.205   * @param propertiesOrFieldsUsedInComparison properties/fields used in comparison.206   * @return {@code this} assertion object.207   * @throws NullPointerException if the actual or other is {@code null}.208   * @throws AssertionError if the actual and the given objects are not equals property/field by property/field on given fields.209   * @throws IntrospectionError if one of actual's property/field to compare can't be found in the other object.210   * @throws IntrospectionError if a property/field does not exist in actual.211   */212  @Deprecated213  public SELF isEqualToComparingOnlyGivenFields(Object other, String... propertiesOrFieldsUsedInComparison) {214    objects.assertIsEqualToComparingOnlyGivenFields(info, actual, other, comparatorsByPropertyOrField, getComparatorsByType(),215                                                    propertiesOrFieldsUsedInComparison);216    return myself;217  }218  /**219   * @deprecated Use the recursive comparison by calling {@link #usingRecursiveComparison()} and chain with220   * {@link RecursiveComparisonAssert#ignoringFields(String...) ignoringFields(String...)}.221   * <p>222   * This method is deprecated because it only compares the first level of fields while the recursive comparison traverses all223   * fields recursively (only stopping at java types).224   * <p>225   * For example suppose actual and expected are of type A which has the following structure:226   * <pre><code class="text"> A227   * |â B b228   * |    |â String s229   * |    |â C c230   * |         |â String s231   * |         |â Date d232   * |â int i</code></pre>233   * {@code isEqualToIgnoringGivenFields} will compare actual and expected {@code A.b} and {@code A.i} fields but not B fields234   * (it calls B equals method instead comparing B fields).<br>235   * The recursive comparison on the other hand will introspect B fields and then C fields and will compare actual and expected236   * respective fields values, that is: {@code A.i}, {@code A.B.s}, {@code A.B.C.s} and {@code A.B.C.d}.237   * <p>238   * Concretely instead of writing:239   * <pre><code class='java'> assertThat(actual).isEqualToIgnoringGivenFields(expected, "i", "b.s");</code></pre>240   * You should write:241   * <pre><code class='java'> assertThat(actual).usingRecursiveComparison()242   *                   .ignoringFields("i", "b.s")243   *                   .isEqualTo(expected);</code></pre>244   * <p>245   * Note that the recursive comparison also allows to ignore fields246   * {@link RecursiveComparisonAssert#ignoringFieldsOfTypes(Class...) by type} or247   * {@link RecursiveComparisonAssert#ignoringFieldsMatchingRegexes(String...) matching regexes}.248   * <b>Original javadoc</b>249   * <p>250   * Asserts that the actual object is equal to the given one by comparing their properties/fields <b>except for the given ones</b>251   * (inherited ones are taken into account). This can be handy if {@code equals} implementation of objects to compare does not suit you.252   * <p>253   * Note that comparison is <b>not</b> recursive, if one of the property/field is an Object, it will be compared to the other254   * field using its {@code equals} method.255   * <p>256   * If an object has a field and a property with the same name, the property value will be used over the  field.257   * <p>258   * Private fields are used in comparison but this can be disabled using259   * {@link Assertions#setAllowComparingPrivateFields(boolean)}, if disabled only <b>accessible </b>fields values are260   * compared, accessible fields include directly accessible fields (e.g. public) or fields with an accessible getter....

Source:RecursiveAssertionConfiguration.java

...107   * If some object under test fields are null it is not possible to evaluate their types and thus these fields are not ignored.108   * <p>109   * When a field is ignored, all its fields are ignored too.110   * <p>111   * Example: see {@link RecursiveAssertionAssert#ignoringFieldsOfTypes(Class[])}112   *113   * @param types the types we want to ignore in the object under test fields.114   */115  @Override116  public void ignoreFieldsOfTypes(Class<?>... types) {117    super.ignoreFieldsOfTypes(types);118  }119  /**120   * Makes the recursive assertion to use the specified {@link OptionalAssertionPolicy}.121   *122   * @param optionalAssertionPolicy the {@link OptionalAssertionPolicy} to use.123   */124  public void setOptionalAssertionPolicy(OptionalAssertionPolicy optionalAssertionPolicy) {125    this.optionalAssertionPolicy = optionalAssertionPolicy;...

Source:RecursiveAssertionAssert.java

...260   * sherlock.address.number = 221;261   *262   * // assertion succeeds because Person has only String fields except for address  (address fields are ignored)263   * assertThat(sherlock).usingRecursiveAssertion()264   *                     .ignoringFieldsOfTypes(Address.class)265   *                     .allFieldsSatisfy(field -> field instanceof String);266   *267   * // assertion fails because of address and address.number fields268   * assertThat(sherlock).usingRecursiveAssertion()269   *                     .allFieldsSatisfy(field -> field instanceof String);</code></pre>270   *271   * @param typesToIgnore the types we want to ignore in the object under test fields.272   * @return this {@link RecursiveAssertionAssert} to chain other methods.273   */274  public RecursiveAssertionAssert ignoringFieldsOfTypes(Class<?>... typesToIgnore) {275    recursiveAssertionConfiguration.ignoreFieldsOfTypes(typesToIgnore);276    return this;277  }278  /**279   * Choose between running the {@link Predicate} in use over the primitive fields of an object in an object tree or not,280   * by default asserting over primitives is <em>enabled</em>.281   * <p>282   * For example, consider the following class:283   * <pre><code class='java'> class Example {284   *    public int primitiveField;285   *    public String objectField;286   *  } </code></pre>287   * <p>288   * By default, the assertion being applied recursively will be applied to <code>primitiveField</code> and to...

ignoringFieldsOfTypes

Using AI Code Generation

1package com.example;2import static org.assertj.core.api.Assertions.assertThat;3import java.util.ArrayList;4import java.util.List;5import org.junit.Test;6public class RecursiveAssertionAssertTest {7    public void testIgnoringFieldsOfTypes() {8        List<String> list = new ArrayList<>();9        list.add("a");10        list.add("b");11        list.add("c");12        List<String> list2 = new ArrayList<>();13        list2.add("a");14        list2.add("b");15        list2.add("c");16        assertThat(list).usingRecursiveComparison().ignoringFieldsOfTypes(Integer.class).isEqualTo(list2);17    }18}19at org.junit.Assert.fail(Assert.java:88)20at org.junit.Assert.failNotEquals(Assert.java:834)21at org.junit.Assert.assertEquals(Assert.java:118)22at org.junit.Assert.assertEquals(Assert.java:144)23at com.example.RecursiveAssertionAssertTest.testIgnoringFieldsOfTypes(RecursiveAssertionAssertTest.java:19)

ignoringFieldsOfTypes

Using AI Code Generation

1import org.assertj.core.api.RecursiveComparisonConfiguration;2import org.junit.Test;3import static org.assertj.core.api.Assertions.assertThat;4public class RecursiveComparisonConfigurationTest {5    public void testRecursiveComparisonConfiguration() {6        RecursiveComparisonConfiguration recursiveComparisonConfiguration = RecursiveComparisonConfiguration.builder().build();7        assertThat(recursiveComparisonConfiguration).ignoringFieldsOfTypes(String.class);8    }9}10import org.assertj.core.api.RecursiveComparisonConfiguration;11import org.junit.Test;12import static org.assertj.core.api.Assertions.assertThat;13public class RecursiveComparisonConfigurationTest {14    public void testRecursiveComparisonConfiguration() {15        RecursiveComparisonConfiguration recursiveComparisonConfiguration = RecursiveComparisonConfiguration.builder().build();16        assertThat(recursiveComparisonConfiguration).ignoringFieldsOfTypes(String.class);17    }18}19import org.assertj.core.api.RecursiveComparisonConfiguration;20import org.junit.Test;21import static org.assertj.core.api.Assertions.assertThat;22public class RecursiveComparisonConfigurationTest {23    public void testRecursiveComparisonConfiguration() {24        RecursiveComparisonConfiguration recursiveComparisonConfiguration = RecursiveComparisonConfiguration.builder().build();25        assertThat(recursiveComparisonConfiguration).ignoringFieldsOfTypes(String.class);26    }27}28import org.assertj.core.api.RecursiveComparisonConfiguration;29import org.junit.Test;30import static org.assertj.core.api.Assertions.assertThat;31public class RecursiveComparisonConfigurationTest {32    public void testRecursiveComparisonConfiguration() {33        RecursiveComparisonConfiguration recursiveComparisonConfiguration = RecursiveComparisonConfiguration.builder().build();34        assertThat(recursiveComparisonConfiguration).ignoringFieldsOfTypes(String.class);35    }36}37import org.assertj.core.api.RecursiveComparisonConfiguration;38import org.junit.Test;39import static org.assertj.core.api.Assertions.assertThat;40public class RecursiveComparisonConfigurationTest {41    public void testRecursiveComparisonConfiguration() {42        RecursiveComparisonConfiguration recursiveComparisonConfiguration = RecursiveComparisonConfiguration.builder().build();43        assertThat(recursiveComparisonConfiguration).ignoringFieldsOfTypes(String.class);44    }45}

ignoringFieldsOfTypes

Using AI Code Generation

1import org.assertj.core.api.RecursiveComparisonAssert;2import org.assertj.core.api.Assertions;3import java.util.List;4import java.util.ArrayList;5class RecursiveComparisonAssertIgnoringFieldsOfTypes {6    public static void main(String[] args) {7        List<String> list1 = new ArrayList<>();8        list1.add("abc");9        list1.add("def");10        List<String> list2 = new ArrayList<>();11        list2.add("abc");12        list2.add("def");13        RecursiveComparisonAssert<String> recursiveComparisonAssert = Assertions.assertThat("abc");14        RecursiveComparisonAssert<String> recursiveComparisonAssert2 = recursiveComparisonAssert.ignoringFieldsOfTypes(String.class);15        System.out.println(recursiveComparisonAssert2);16    }17}

ignoringFieldsOfTypes

Using AI Code Generation

1import org.assertj.core.api.*;2import org.assertj.core.api.recursive.comparison.*;3import org.assertj.core.api.recursive.comparison.FieldLocation.*;4import java.util.*;5import org.assertj.core.api.recursive.comparison.*;6import org.assertj.core.api.recursive.comparison.FieldLocation.*;7class A {8    int a;9    String b;10    List<String> c;11    List<List<String>> d;12    List<List<List<String>>> e;13    List<List<List<List<String>>>> f;14    List<List<List<List<List<String>>>>> g;15    List<List<List<List<List<List<String>>>>>> h;16    List<List<List<List<List<List<List<String>>>>>>> i;17    List<List<List<List<List<List<List<List<String>>>>>>>> j;18    List<List<List<List<List<List<List<List<List<String>>>>>>>>> k;19    List<List<List<List<List<List<List<List<List<List<String>>>>>>>>>> l;

ignoringFieldsOfTypes

Using AI Code Generation

1public class RecursiveAssertionAssertIgnoringFieldsOfTypes {2    public static void main(String[] args) {3        Person person = new Person();4        person.name = "John";5        person.address = new Address();6        person.address.street = "Main Street";7        person.address.number = 123;8        assertThat(person).ignoringFieldsOfTypes(Address.class).isEqualTo(person);9    }10}11class Person {12    String name;13    Address address;14}15class Address {16    String street;17    int number;18}19at org.assertj.core.api.RecursiveComparisonAssert.recursiveComparison(RecursiveComparisonAssert.java:189)20at org.assertj.core.api.AbstractAssert.isEqualTo(AbstractAssert.java:82)21at org.assertj.core.api.AssertionsForClassTypes.isEqualTo(AssertionsForClassTypes.java:121)22at com.javabyexamples.java.test.assertj.recursiveassertionassert.RecursiveAssertionAssertIgnoringFieldsOfTypes.main(RecursiveAssertionAssertIgnoringFieldsOfTypes.java:11)

ignoringFieldsOfTypes

Using AI Code Generation

1import org.assertj.core.api.RecursiveComparisonAssert;2import org.assertj.core.api.AbstractObjectAssert;3import org.assertj.core.api.Assertions;4import org.assertj.core.api.ObjectAssert;5import org.assertj.core.util.introspection.IntrospectionError;6class Test {7  public static void main(String[] args) {8    RecursiveComparisonAssert<Person> recursiveComparisonAssert = Assertions.assertThat(new Person("John", "Smith", 35)).usingRecursiveComparison();9    AbstractObjectAssert<?, Person> abstractObjectAssert = recursiveComparisonAssert.ignoringFieldsOfTypes(Integer.class);10  }11}12import org.assertj.core.api.AbstractObjectAssert;13import org.assertj.core.api.Assertions;14import org.assertj.core.api.ObjectAssert;15import org.assertj.core.util.introspection.IntrospectionError;16class Test {17  public static void main(String[] args) {18    AbstractObjectAssert<?, Person> abstractObjectAssert = Assertions.assertThat(new Person("John", "Smith", 35)).ignoringFieldsOfTypes(Integer.class);19  }20}21import org.assertj.core.api.ObjectAssert;22import org.assertj.core.api.Assertions;23import org.assertj.core.util.introspection.IntrospectionError;24class Test {25  public static void main(String[] args) {26    ObjectAssert<Person> objectAssert = Assertions.assertThat(new Person("John", "Smith", 35)).ignoringFieldsOfTypes(Integer.class);27  }28}29import org.assertj.core.api.AbstractAssert;30import org.assertj.core.api.Assertions;31import org.assertj.core.util.introspection.IntrospectionError;32class Test {33  public static void main(String[] args) {34    AbstractAssert<?, Person> abstractAssert = Assertions.assertThat(new Person("John", "Smith", 35)).ignoringFieldsOfTypes(Integer.class);35  }36}37import org.assertj.core.api.AbstractComparableAssert;38import org.assertj.core.api.Assertions;39import org.assertj.core.util.introspection.IntrospectionError;40class Test {41  public static void main(String[] args) {

ignoringFieldsOfTypes

Using AI Code Generation

1import org.assertj.core.api.RecursiveComparisonAssert;2import org.assertj.core.api.RecursiveComparisonConfiguration;3import org.assertj.core.api.Assertions;4import java.util.*;5class Test {6    public static void main(String[] args) {7        List<String> list1 = Arrays.asList("a", "b", "c");8        List<String> list2 = Arrays.asList("a", "b", "c");9        RecursiveComparisonConfiguration configuration = new RecursiveComparisonConfiguration();10        configuration.ignoreFieldsOfTypes(List.class);11        Assertions.assertThat(list1).usingRecursiveComparison(configuration).isEqualTo(list2);12    }13}14ignoreFieldsOfTypes(List.class)15at org.assertj.core.api.RecursiveComparisonAssert.recursiveComparison(RecursiveComparisonAssert.java:111)16at org.assertj.core.api.RecursiveComparisonAssert.ignoringFieldsOfTypes(RecursiveComparisonAssert.java:89)17at Test.main(Test.java:15)18import org.assertj.core.api.RecursiveComparisonAssert;19import org.assertj.core.api.RecursiveComparisonConfiguration;20import org.assertj.core.api.Assertions;21import java.util.*;22class Test {23    public static void main(String[] args) {24        List<String> list1 = Arrays.asList("a", "b", "c");25        List<String> list2 = Arrays.asList("a", "b", "c");26        RecursiveComparisonConfiguration configuration = new RecursiveComparisonConfiguration();27        configuration.ignoreFieldsOfTypes(List.class);28        Assertions.assertThat(list1).usingRecursiveComparison(configuration).isEqualTo(list2);29    }30}

ignoringFieldsOfTypes

Using AI Code Generation

1package org.example;2import static org.assertj.core.api.Assertions.assertThat;3import java.util.List;4import org.junit.Test;5public class Test1 {6	public void test1() {7		assertThat(List.of(1, 2, 3)).ignoringFieldsOfTypes(List.class).isEqualTo(List.of(1, 2, 3));8	}9}10package org.example;11import static org.assertj.core.api.Assertions.assertThat;12import java.util.List;13import org.junit.Test;14public class Test2 {15	public void test1() {16		assertThat(List.of(1, 2, 3)).ignoringFieldsOfTypes(List.class).isEqualTo(List.of(1, 2, 3));17	}18}19package org.example;20import static org.assertj.core.api.Assertions.assertThat;21import java.util.List;22import org.junit.Test;23public class Test3 {24	public void test1() {25		assertThat(List.of(1, 2, 3)).ignoringFieldsOfTypes(List.class).isEqualTo(List.of(1, 2, 3));26	}27}28package org.example;29import static org.assertj.core.api.Assertions.assertThat;30import java.util.List;31import org.junit.Test;32public class Test4 {33	public void test1() {34		assertThat(List.of(1, 2, 3)).ignoringFieldsOfTypes(List.class).isEqualTo(List.of(1, 2, 3));35	}36}37package org.example;38import static org.assertj.core.api.Assertions.assertThat;39import java.util.List;40import org.junit.Test;41public class Test5 {42	public void test1() {43		assertThat(List.of(1, 2, 3)).ignoringFieldsOfTypes(List.class).isEqualTo(List.of(1, 2, 3));44	}45}46package org.example;

ignoringFieldsOfTypes

Using AI Code Generation

1import org.junit.Test;2import static org.assertj.core.api.Assertions.assertThat;3public class AssertJTest {4    public void testAssertJ() {5        Person person = new Person();6        person.setName("John Doe");7        person.setAge(25);8        person.setAddress(new Address("123 Main Street", "New York", "NY", "12345"));9        person.setPhone(new Phone("123-456-7890"));10        Person person2 = new Person();11        person2.setName("John Doe");12        person2.setAge(25);13        person2.setAddress(new Address("123 Main Street", "New York", "NY", "12345"));14        person2.setPhone(new Phone("123-456-7890"));15        Person person3 = new Person();16        person3.setName("John Doe");17        person3.setAge(25);18        person3.setAddress(new Address("123 Main Street", "New York", "NY", "12345"));19        person3.setPhone(new Phone("123-456-7890"));20        assertThat(person).isNotEqualTo(person2);21        assertThat(person).isNotEqualTo(person3);22        assertThat(person2).isNotEqualTo(person3);23        assertThat(person).isEqualToIgnoringGivenFields(person2, "phone");24        assertThat(person).isEqualToIgnoringGivenFields(person3, "phone");25        assertThat(person2).isEqualToIgnoringGivenFields(person3, "phone");26        assertThat(person).isEqualToIgnoringGivenFields(person2, "phone", "address");27        assertThat(person).isEqualToIgnoringGivenFields(person3, "phone", "address");28        assertThat(person2).isEqualToIgnoringGivenFields(person3, "phone", "address");29    }30}31public class Person {32    private String name;33    private int age;34    private Address address;35    private Phone phone;36    public String getName() {37        return name;38    }39    public void setName(String name) {40        this.name = name;41    }42    public int getAge() {43        return age;44    }45    public void setAge(int age) {46        this.age = age;47    }48    public Address getAddress() {49        return address;50    }51    public void setAddress(Address address) {52        this.address = address;53    }54    public Phone getPhone() {55        return phone;56    }57    public void setPhone(Phone phone

ignoringFieldsOfTypes

Using AI Code Generation

1public class RecursiveAssertionAssertIgnoringFieldsOfTypes {2    public static void main(String[] args) {3        Person person = new Person("John", "Doe", 40);4        person.friends.add(new Person("Jane", "Doe", 35));5        person.friends.add(new Person("Jack", "Doe", 5));6        Person person2 = new Person("John", "Doe", 40);7        person2.friends.add(new Person("Jane", "Doe", 35));8        person2.friends.add(new Person("Jack", "Doe", 5));9        assertThat(person).usingRecursiveComparison()10                .ignoringFieldsOfTypes(Person.class)11                .isEqualTo(person2);12    }13}14public class Person {15    public String firstName;16    public String lastName;17    public int age;18    public List<Person> friends = new ArrayList<>();19    public Person(String firstName, String lastName, int age) {20        this.firstName = firstName;21        this.lastName = lastName;22        this.age = age;23    }24}25when recursively comparing field by field, but found the following difference(s):

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.