Add more assertion on ClassAssert

Summary

Apologies, If I’m wrong.

It’s nice that the ClassAssert already has an assertion for Class#isAssignableFrom. An assertion of opposite flow may be more intuitive, I believe. Say, we have the following class or any other class being expected to implement the MyInterface interface.

class MyClass
        extends HisClass // which extends HerClass
        implements MyInterface {
}

HerClass
    HisClass
        MyClass

We can,

// Asserts that MyInterface.class is assignable from MyClass.class, based on Class#isAssignableFrom
assertThat(MyInterface.class)
        .isAssignableFrom(MyClass.class);
// Asserts that MyClass.class has HisClass.class as direct superclass.
assertThat(MyClass.class)
        .hasSuperclass(HisClass.class);

But following idiom(s) will be more intuitive.

// Asserts that MyClass implements MyInterface
assertThat(MyClass.class)
        .implements(MyInterface.class)
        .isAssignableTo(MyInterface.class);
// Or
assertThat(MyClass.class)
        .implements(MyInterface.class)
        .isSubclassOf(HisClass.class) // is direct subclass; opposite of hasSuperclass(superClass)
        .isDescendentOf(HisClass.class)
        .isDescendentOf(HerClass.class) // is direct or transitively
;
assertThat(HisClass.class)
        .isAscendentOf(MyClass.class)
        .isSubclassOf(HerClass.class)
        .isDescendentOf(HerClass.class);

• isAssignableTo(classOrInterface)
• implements(interfaceClass)
• isSubclassOf(superClass) - is direct subclass of
• is(Descendant|Descendent)Of(ascendentClass) - is direct or transitive descendent of
• is(Ancestor|Ascendent)Of(descendentClass) - is direct or transitive ascendent of

[scordio]

Alternative naming proposal from https://github.com/assertj/assertj-core/issues/2545#issuecomment-1081352291 for the isAssignableTo assertion:

• isCompatibleWith / isNotCompatibleWith

[perlun]

@scordio Sorry for the late call, but yes, I think isAssignableTo and isAssignableFrom are good enough for now. 👍

isSubclassOf/hasParent are quite interesting (but not directly required by me). I think they are unpleasantly “less precise” though; they first one would perhaps more rightfully be isDirectSubclassOf since in an A -> B -> C, C is by definition a subclass of A as well as of B. hasParent is perhaps less unambiguous in this since parents and grandparents are conceptually different. 🙂