import org.mockito.invocation.MockHandler; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void addAnswersForStubbing(MockitoMethodInvocationControl invocationControl) {
    final MockHandler mockHandler = invocationControl.getInvocationHandler().getHandler();
    final List list = Whitebox.getInternalState(this, List.class);
    try {
        Whitebox.invokeMethod(mockHandler, "setAnswersForStubbing", list);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public MockHandler getHandler(Object mock) {
    // Return a fake mock handler for static method mocks
    if(mock instanceof Class) {
        return new PowerMockInternalMockHandler((Class<?>) mock);
    } else {
        return cglibMockMaker.getHandler(mock);
    }
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
private MockHandler replaceMatchersBinderIfNeeded(MockHandler mockHandler) {
    if(!Whitebox.getFieldsOfType(mockHandler, MatchersBinder.class).isEmpty()) {
        Whitebox.setInternalState(mockHandler, new PowerMockMatchersBinder());
    } else if(!Whitebox.getFieldsOfType(mockHandler, InternalMockHandler.class).isEmpty()) {
        final MockHandler internalMockHandler = Whitebox.getInternalState(mockHandler, MockHandler.class);
        return replaceMatchersBinderIfNeeded(internalMockHandler);
    }
    return mockHandler;
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
private InternalMockHandler cast(MockHandler handler) {
    if (!(handler instanceof InternalMockHandler)) {
        throw new MockitoException("At the moment you cannot provide own implementations of MockHandler." +
                "\nPlease see the javadocs for the MockMaker interface.");
    }
    return (InternalMockHandler) handler;
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public MockHandler getHandler(Object mock) {
    if (!(mock instanceof Factory)) {
        return null;
    }
    Factory factory = (Factory) mock;
    Callback callback = factory.getCallback(0);
    if (!(callback instanceof MethodInterceptorFilter)) {
        return null;
    }
    return ((MethodInterceptorFilter) callback).getHandler();
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public <T> T createMock(MockCreationSettings<T> settings) {
    MockHandler mockHandler = new MockHandlerFactory().create(settings);

    T mock = mockMaker.createMock(settings, mockHandler);

    Object spiedInstance = settings.getSpiedInstance();
    if (spiedInstance != null) {
        new LenientCopyTool().copyToMock(spiedInstance, mock);
    }

    return mock;
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public <T> void resetMock(T mock) {
    InternalMockHandler oldHandler = (InternalMockHandler) getMockHandler(mock);
    MockCreationSettings settings = oldHandler.getMockSettings();
    MockHandler newHandler = new MockHandlerFactory().create(settings);

    mockMaker.resetMock(mock, newHandler, settings);
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public <T> InternalMockHandler<T> getMockHandler(T mock) {
    if (mock == null) {
        throw new NotAMockException("Argument should be a mock, but is null!");
    }

    if (isMockitoMock(mock)) {
        MockHandler handler = mockMaker.getHandler(mock);
        return (InternalMockHandler) handler;
    } else {
        throw new NotAMockException("Argument should be a mock, but is: " + mock.getClass());
    }
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
@Override
public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
    InvocationHandlerAdapter adapter = getInvocationHandlerAdapter(mock);
    if (adapter != null) {
        adapter.setHandler(newHandler);
    }
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
    return cglibMockMaker.createMock(settings, handler);
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
    cglibMockMaker.resetMock(mock, newHandler, settings);
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public MockHandler getHandler() {
    return handler;
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
    InternalMockHandler mockitoHandler = cast(handler);
    new AcrossJVMSerializationFeature().enableSerializationAcrossJVM(settings);
    return new ClassImposterizer(new InstantiatorProvider().getInstantiator(settings)).imposterise(
            new MethodInterceptorFilter(mockitoHandler, settings), settings.getTypeToMock(), settings.getExtraInterfaces());
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
    ((Factory) mock).setCallback(0, new MethodInterceptorFilter(cast(newHandler), settings));
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public InvocationHandlerAdapter(MockHandler handler) {
  this.handler = handler;
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public MockHandler getHandler() {
  return handler;
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public void setHandler(MockHandler handler) {
  this.handler = handler;
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
@Override
public MockHandler getHandler(Object mock) {
  InvocationHandlerAdapter adapter = getInvocationHandlerAdapter(mock);
  return adapter != null ? adapter.getHandler() : null;
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
@Override
@SuppressWarnings("rawtypes")
public void resetMock(Object mock, MockHandler newHandler, MockCreationSettings settings) {
  InvocationHandlerAdapter adapter = getInvocationHandlerAdapter(mock);
  adapter.setHandler(newHandler);
}
 

import org.mockito.invocation.MockHandler; //导入依赖的package包/类
public <T> T createMock(MockCreationSettings<T> settings, MockHandler handler) {
    InternalMockHandler mockitoHandler = cast(handler);
    new AcrossJVMSerializationFeature().enableSerializationAcrossJVM(settings);
    return ClassImposterizer.INSTANCE.imposterise(
            new MethodInterceptorFilter(mockitoHandler, settings), settings.getTypeToMock(), settings.getExtraInterfaces());
}