Any way to cut recursion on a certain Type excluding root object ?

[clement-re]

Hi,

I'm trying to compare two objects recursively, but I dont want a certain Type to use recursive comparison (lets call it GenericObject).
Seems easy to do with .withEqualsForType(Object:equals, GenericObject.class)
Only problem with this method is the root object is also a GenericObject, so it cuts recursion directly on root object.
Is there a way to add an exception for the root object ?

Right now to achieve this comparison I use .withEqualsForFields(Object::equals, genericObjectFieldNames) but this forces me to get all GenericObject field names using reflection.

Do you see a better way to achieve this kind of comparison ?

[joel-costigliola]

One solution I see is a bit of a hack, create a Wrapper class like and use it to wrap you object and expected object with it so that it avoids the root object issue:

  class Wrapper<T> {
    T object;
    Wrapper(T object) {
      this.optional = optional;
    }
  }

I'll think about adding an option to avoid considering the root object in the comparison if we have more use cases for it, your case being quite specific.

[joel-costigliola]

Ah yeah true, my comment is not relevant then, sorry about that.

Would adding support for withEqualsForFieldsMatchinRegexes lead to a better solution in your case? I'm assuming your GenericObject fields can be "easily" matched by regexes. We already have something similar for ignoring fields https://www.javadoc.io/doc/org.assertj/assertj-core/latest/org/assertj/core/api/RecursiveComparisonAssert.html#ignoringFieldsMatchingRegexes(java.lang.String...).

[joel-costigliola]

If you could provide a reproducible example, that would help us validating that our answers make sense (especially mine! 😉 )

[clement-re]

No worries, I understand my case is quite specific.

Unfortunately, I don't think regexes would work with my case.
To give a little more details, GenericObject is the root of many classes, thus I cannot know in advance the name of the attributes of this Type.

I'll try to give an example as simple as I can. Let me know if anything isn't clear.

Example :

public class GenericObject {
	String string;

	[...]
}

public class AnyObject extends GenericObject {
	GenericObject anyAttribute;
	int number;
	
	[...]
}
------------------------------------------------------------------------------------------------------------
AnyObject object1 = new AnyObject(new GenericObject("abc"), 10);
AnyObject object2 = new AnyObject(new GenericObject("bcd"), 10);

// should return true
assertThat(object1 ).usingRecursiveComparison()
                    .using[...] // A trick to cut recursion on all GenericObject except for root objects (object1 and object2)
                    .isEqualTo(object2);
------------------------------------------------------------------------------------------------------------
AnyObject object1 = new AnyObject(new GenericObject("abc"), 10);
AnyObject object2 = new AnyObject(new GenericObject("bcd"), 133);

// should return false
assertThat(object1 ).usingRecursiveComparison()
                    .using[...] // A trick to cut recursion on all GenericObject except for root objects (object1 and object2)
                    .isEqualTo(object2);

[clement-re]

I've been able to cut recursion on a certain Type except root object, by converting the root object to a map before doing the comparison.
Not a perfect solution, but it seems to work fine so far.