ClassCastException with Generics and Mockito

Question

I have this case using JDK6, Junit3, and Mockito 1.8.5 (names have been changed to make it easily understandable):

public abstract class AbstractProcessorTest<P extends AbstractProcessor<T>, T extends AbstractProcess> {

@Mock(answer = CALLS_REAL_METHODS)
protected P processor;

@Mock(answer = RETURN_DEEP_STUBS)
protected T process;

public void setUp(){
 Mockito.initMocks(this);
 // some common configurations
 processor.setProcess(process);
 ...
}

}

public class ProcessorTest extends AbstractProcessorTest<Processor, ProcessAlpha>{    

@Mock
private Service service;

@Override
public void setUp(){
   super.setUp();
   doReturn(service).when(processor).getService();
}

public void testAMethod(){          
   processor.process();
}

}

When I execute the testAMethod() test case, I'm getting this exception:

java.lang.ClassCastException: org.xyz.AbstractProcessor$$EnhancerByMockitoWithCGLIB$$c948b334 cannot be cast to org.xyz.ProcessorA

When I inspect this method call, it says that this method cannot be found in the class. Another weird thing is I'm not getting any exception while calling methods in AbstractProcessor.setUp() (but it fails in ProcessorTest.setUp())

This wasn't happening before I created the AbstractProcessorTest class, so I believe it's some stuff related to the generics and the way Mockito proxies these objects, that I need to change my strategy.

Hope this was clear enough. Thank you in advance,

Sebas.-

But I'm not really mocking an abstract class. ProcessorA is a concrete implementation of AbstractProcessor. I need to mock it to proxy an specific method call. I will update the code. — Sebastian
– Sebastian, Commented Apr 9, 2013 at 15:50

bric3 · Accepted Answer · 2015-01-09 10:57:42Z

4

So I my previous was not relevant to actual problem. Though the answer still holds true such exception happens when a mock using deep stubs answer returns a mock.

So what is the real issue, it's still caused by generics and type erasure. You have two different classes:

The test:

public class ProcessorTest extends AbstractProcessorTest<Processor, ProcessAlpha>

And the parent of the test :

public abstract class AbstractProcessorTest<P extends AbstractProcessor<T>, T extends AbstractProcess> {

@Mock(answer = ...)
protected P processor;

So the compiler will first compile AbstractProcessorTest, when doing so it will see that P is in fact an AbstractProcessor, and it will compile the class this way.
Then the compiler will compile ProcessorTest and will see that P will be resolved to Processor, but it won't modify AbstractProcessorTest as it's already compiled. Still it will take into account P everywhere possible in ProcessorTest, so its bytecode may contain possible cast opcodes.
When you run it, the current Mockito code charged to instantiate mocks based on fields will see for field P processor the type AbstractProcessor not the type Processor that you fixed in ProcessorTest. Of course it will create the mock accordingly.
The CCE is raised in the ProcessorTest.setUp method because the compiler certainly introduced a silent cast opcode due to the generic nature of the field processor.

Also it looks reaaaally weird to configure mocks to call real method, it can lead to many issues, as mocks are not initialized with state. Maybe you want to use a spy instead ?

Hope that helps.

Previous answer that wasn't actually answering the real issue. But might still prove helpful with Mockito deep stubs

Yes Mockito in the current released version (1.9.5) doesn't support generics with deep stub (see issue 230), because Java implements generics with type erasure. So you it will only find the superior bound, be it Object or some other type that is known after erasure.

Generics are more of a compiler stuff than a runtime stuff. Search google about why java people would like reified generics for a long long time. Neal Gafter wrote about it in 2006 http://gafter.blogspot.fr/2006/11/reified-generics-for-java.html, but there is other interesting reads out there.

EDITED vvvvvvvv 2015-01

However the compiler embeds some data about generics in some specific cases, in your example with this class declaration public class ProcessorTest extends AbstractProcessorTest<Processor, ProcessAlpha> it is possible to read both types. ~~using the clunky and slow reflection API. The code exists in the master of Mockito code and should work in your example, but it is still unreleased due to other issues.~~

Since Mockito 1.10.x Mockito is way more aware of generics, i.e. if the mocked type like this declaration embeds types or boundaries it will use them, if a method has boundaries it will use them.

That means that code like that will work without additional stubbing, i.e mockito will discover boundaries embedded in bytecode and mock them if possible (not final nor primitive) :

interface UberList<U> extends List<U extends Uber> {
    U firstUber();
    <D extends Driver> D driver();
}

uberList = mock(UberList.class, RETURNS_DEEP_STUB);

Uber u1 = uberList.iterator().next();
Uber u1 = uberList.firstUber();
Driver d = uberList.driver();

EDITED ^^^^^^^^

Of course runtime declaration still cannot be discovered. For example in List<Processor> pList; the Processor generic type info will be erased. The only available info that will be the one that compiler found while compiling List. Without displaying too much details on how it's done, that type information will be resolved to Object as the generic type information E upper bound will be resoled to Object by the compiler (it's an implicit upper bound, just as you don't have to write extends Object).

So, in the mean time you could either cast to the wanted type, simply don't use the deep stubs answer, or if you are adventurous you can compile yourself an unreleased version of Mockito with the updated deep stub answer.

Hope that helps.

edited Jan 9, 2015 at 10:57

answered Apr 9, 2013 at 16:47

bric3

42.7k9 gold badges99 silver badges116 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Sebastian Over a year ago

Thank you for your complete answer! One thing I don't know if I got right, is the fact that this problem comes out because my Processor class is typed. So if I would have Processor instead of Processor<P>, this would work? (referring to the fact that P is declared as DEEP_STUBS). I thought this whole issue was related to the CALLS_REAL_METHODS. Correct me if I'm wrong.

bric3 Over a year ago

Eeek, I misread your question, check the answer updated accordingly.

Sebastian Over a year ago

Hi, sorry I took so long to reply. I had to leave this aside since other stuff came up urgently. An alternate solution was to declare an abstract method to instanciate the contributors accordingly. I was thinking about something like: P getProcessorClass() and then mocking it in the abstract class, but I cannot do Processor<Process>.class, so I'm afraid I'll have to instanciate the mocks in each test case. Thank you very much!

bric3 Over a year ago

@Sebastian You are welcome. well generics in Java are not quite friendly. If that might of interest to you, there's a link with many useful info that Angelika Langer found out when she encountered issues with generics.

Collectives™ on Stack Overflow

ClassCastException with Generics and Mockito

1 Answer 1

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related