Testing several implementations of generic interface

[Istvan Kovacs]

Dear All,

I'd like to write a unit test for classes implementing the same generic interface, Something<T> - the classes are solutions to the same puzzle from different students, and I don't want to influence the types they use for data storage, or the algorithm they use to generate the result, as long as the implementation passes the tests. Each class implements Something<T> with a specific class, e.g.

interface Something<T> {
  T createThing();
  void doSomething(T one, T other);
  Set<T> getThings();

}

public class IntegerThing implements Something<Integer> {
  private int counter;
    public Integer createThing() {
    return counter++;
  }
  public void doSomething(Integer one, Integer other) {
    // ...here is the magic puzzle solver algorithm...
  }
  public Set<Integer> getThings() {
    Set<Integer> result = new HashSet<Integer>();
    // ...fill result set...
    return result;
  }

}

// another solution with more magic
public class StringThing implements Something<String> {...}

Then, I'd like to have a test where I only need to change the line that instantiates the object (Something<T> implementation) under test. I've come up with:

public class ThingTest<T> {
  // change instantiation below to test each solution; we have an ugly warning here
  private Something<T> underTest = (Something<T>) new IntegerThing();

  @Test
  public void test() {
    T thingA = underTest.createThing();
    T thingB = underTest.createThing();
    underTest.doSomething(thingA, thingB);
    Set<T> result = underTest.getThings();
    // assert whatever...
  }

}

I don't want to create a whole parallel tree of ThingTest<Integer>, ThingTest<String>; this would be used to test each class just one, to verify puzzle solutions from students (the aim is to let them use whatever data structure they choose or create, that's why I'd like to keep this generic). To check each solution, I'd just replace new IntegerThing() with whatever class they used.

Now, this works fine, but gives me a warning: unchecked cast from IntegerThing to Something<T>[u]. Is there a way to avoid this? At compile time, it is known that [u]IntegerThing implements Something<Integer>; is there a way to get the compiler figure out that T is Integer in this case?

Thanks,
Kofa

[Ireneusz Kordal]

Istvan Kovacs wrote:
Now, this works fine, but gives me a warning: unchecked cast from IntegerThing to Something<T>[u]. Is there a way to avoid this? At compile time, it is known that [u]IntegerThing implements Something<Integer>; is there a way to get the compiler figure out that T is Integer in this case?

Use @SuppressWarnings("unchecked") annotation.

[Istvan Kovacs]

Use @SuppressWarnings("unchecked") annotation

:-)
I know how I can suppress the warning, but that would be my last resort (I know that even some of the code in Java Generics and Collections, which is a great book on the subject, has some warnings that cannot be avoided).

My main concern is that the type parameter on ThingTest<T> does not really belong there. I never instantiate ThingTest<This> or ThingTest<That>; it's always done by the JUnit framework that does not care about generics.

[Istvan Kovacs]

Here's the solution. It works because Something<?> undertest means "the Something interface parameterised with an unknown, but concrete type"; then, it doTest, T captures the wildcard, and becomes that "unknown, but concrete type".

public class ThingTest {
  // change instantiation below to test each solution
  private Something<?> underTest = new IntegerThing();

  @Test
  public void test() {
    doTest(underTest);
  }

  private static <T> void doTest(Something<T> toTest) {
    T thingA = toTest.createThing();
    T thingB = toTest.createThing();
    toTest.doSomething(thingA, thingB);
    Set<T> result = toTest.getThings();
    // assert whatever...
  }
}