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

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

@Testpublic 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);

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:

@Testpublic 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;}

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?