Home » Java » Mockito: Stubbing Methods That Return Type With Bounded Wild-Cards

Mockito: Stubbing Methods That Return Type With Bounded Wild-Cards

Posted by: admin November 30, 2017 Leave a comment

Questions:

Consider this code:

public class DummyClass {
    public List<? extends Number> dummyMethod() {
        return new ArrayList<Integer>();
    }
}
public class DummyClassTest {
    public void testMockitoWithGenerics() {
        DummyClass dummyClass = Mockito.mock(DummyClass.class);
        List<? extends Number> someList = new ArrayList<Integer>();
        Mockito.when(dummyClass.dummyMethod()).thenReturn(someList); //Compiler complains about this
    }
}

The compiler complains about the line that’s trying to stub the behavior for dummyMethod(). Any pointers on how one goes about stubbing methods that return a type with bounded wild-cards?

Answers:

You can also use the non-type safe method doReturn for this purpose,

@Test
public void testMockitoWithGenerics()
{
    DummyClass dummyClass = Mockito.mock(DummyClass.class);
    List<? extends Number> someList = new ArrayList<Integer>();

    Mockito.doReturn(someList).when(dummyClass).dummyMethod();

    Assert.assertEquals(someList, dummyClass.dummyMethod());
}

as discussed on Mockito’s google group.

While this is simpler than thenAnswer, again note that it is not type safe. If you’re concerned about type safety, millhouse’s answer is correct.

Additional Details

To be clear, here’s the observed compiler error,

The method thenReturn(List<capture#1-of ? extends Number>) in the type OngoingStubbing<List<capture#1-of ? extends Number>> is not applicable for the arguments (List<capture#2-of ? extends Number>)

I believe the compiler has assigned the first wildcard type during the when call and then cannot confirm that the second wildcard type in the thenReturn call is the same.

It looks like thenAnswer doesn’t run into this issue because it accepts a wildcard type while thenReturn takes a non-wildcard type, which must be captured. From Mockito’s OngoingStubbing,

OngoingStubbing<T> thenAnswer(Answer<?> answer);
OngoingStubbing<T> thenReturn(T value);

Questions:
Answers:

I’m assuming you want to be able to load up someList with some known values; here’s an approach that uses Answer<T> together with a templated helper method to keep everything type-safe:

@Test
public void testMockitoWithGenericsUsingAnswer()
{
    DummyClass dummyClass =  Mockito.mock(DummyClass.class);

    Answer<List<Integer>> answer = setupDummyListAnswer(77, 88, 99);
    Mockito.when(dummyClass.dummyMethod()).thenAnswer(answer);

    ...
}

private <N extends Number> Answer<List<N>> setupDummyListAnswer(N... values) {
    final List<N> someList = new ArrayList<N>();

    someList.addAll(Arrays.asList(values));

    Answer<List<N>> answer = new Answer<List<N>>() {
        public List<N> answer(InvocationOnMock invocation) throws Throwable {
            return someList;
        }   
    };
    return answer;
}

Questions:
Answers:

I hit the same thing yesterday. Both answers from @nondescript1 and @millhouse helped me to figure out a workaround. I’ve pretty much used the same code as @millhouse, except that I made it slightly more generic, because my error wasn’t caused by a java.util.List, but the com.google.common.base.Optional. My little helper method therefore allows for any type T and not just List<T>:

public static <T> Answer<T> createAnswer(final T value) {
    Answer<T> dummy = new Answer<T>() {
        @Override
        public T answer(InvocationOnMock invocation) throws Throwable {
            return value;
        }
    };
    return dummy;
}

With this helper method you could write:

Mockito.when(dummyClass.dummyMethod()).thenAnswer(createAnswer(someList));

This compiles just fine and does the same thing as the thenReturn(...) method.

Does someone know if the error that the Java compiler emits is a compiler bug or if the code is really incorrect?

Questions:
Answers:

Although the utility method proposed by Marek Radonsky works, there is also an other option which doesn’t even require the (IMHO strange looking) lambda expression fikovnik suggested:

As this answer to a similar question shows, you can also use the following:

BDDMockito.willReturn(someList).given(dummyClass).dummyMethod();