How can I have a unit test that ensures all subclasses implement a method?

Question

I want to make a unit test that will ensure that all subclasses implement a method.

Some code may better explain what I am trying to do.

The super class is like this:

class SuperClass
{
    public boolean isImportant()
    {
        throw customException;
    } 
}

Now say that I have sub classes A and B.

I'd like to ensure that this is included in those classes, so like:

class A extends SuperClass
{
    @Override
    public boolean isImportant()
    { 
        return true; //or false
    }
}

and class b:

class B extends SuperClass
{
}

Now if I do B b = new B(); b.isImportant() I will get the exception.

Instead of having a test for each class (there are many and I may miss some and in the future more subclasses may be added), how can I easily test this.

I am thinking if there is some way to instantiate a object of every subclass.

Something like this:

for(Class subClass : SuperClass.subclasses)
{
   subClass obj = new subClass();
   obj.isImportant();
}

As this will iterate through all the subclasses, regardless of if some are added or removed and will fail if there is an exception thrown.

Is there some way to do this?

Answer 1

Make the method abstract and subclasses have to implement it, or they won't compile. No unit test needed (for that, anyway).

Update

Now, if you can't (or don't want to) change the method to abstract, you can test it like this.

class SuperClass {
    public boolean isImportant() { throw new UnsupportedOperationException(); } 
}

class A extends SuperClass {
    @Override
    public boolean isImportant() { return true; }
}

class B extends SuperClass {
}

class TestIsImportant {

    @SuppressWarnings("unchecked")
    private static final Class<?>[] classesToTest = new Class[] {
        A.class, B.class
    };

    @Test
    public void test() throws Exception {
        for (Class<?> classToTest : classesToTest) {
            classToTest.getDeclaredMethod("isImportant");
        }
    }

}

This will throw NoSuchMethodException if method is not implemented, and it's easy to add to the list of classes to test.

Answer 2

I think what you're trying to test is weird and you should probably go with @Andreas's solution:

Make the method abstract and subclasses have to implement it, or they won't compile. No unit test needed (for that, anyway).

That being said, here's how you'd test what you want:

public class SuperClass {

    public void method() {
        System.out.println("Default implementation.");
    }

}

public class SubClassA extends SuperClass {

    @Override
    public void method() {
        System.out.println("Overridden implementation.");
    }

}

public class SubClassB extends SuperClass {}

public class TestClass {

    @Test
    public void test() throws NoSuchMethodException {
        // nothing happens here
        SubClassA.class.getDeclaredMethod("isImportant");

        // the line below throws NoSuchMethodException, failing the test
        SubClassB.class.getDeclaredMethod("isImportant");
    }

}

Now, if you want to be able to loop through all SuperClass subclasses, you should take a look at this: How do you find all subclasses of a given class in Java?

Answer 3

I don't understand how exactly you think unit testing relates to the inheritance in your case. If you need to ensure that isImportant() is implemented/inherited in the subclasses, simply make A and B extend the SuperClass. Then you can be sure all all subclasses forever will have all the methods of the SuperClass.

class A extends SuperClass {
...

If the method is not implemented in the super class, but you still want to do what you have written, make the SuperClass abstract.

Or finally, define an interface like:

interface SuperInterface {
   boolean isImportant();
}

...and make A and B to implement it. This is probably the cleanest way to do.