Java 类org.mockito.internal.InternalMockHandler 实例源码

Verification(Object target) {
    MockUtil mockUtil = new MockUtil();
    InternalMockHandler<?> handler = mockUtil.getMockHandler(target);
    InvocationContainer container = handler.getInvocationContainer();
    Field field = ReflectionUtils.findField(container.getClass(),
            "mockingProgress");
    ReflectionUtils.makeAccessible(field);
    this.progress = (MockingProgress) ReflectionUtils.getField(field, container);
}

Verification(Object target) {
    MockUtil mockUtil = new MockUtil();
    InternalMockHandler<?> handler = mockUtil.getMockHandler(target);
    InvocationContainer container = handler.getInvocationContainer();
    Field field = ReflectionUtils.findField(container.getClass(),
            "mockingProgress");
    ReflectionUtils.makeAccessible(field);
    this.progress = (MockingProgress) ReflectionUtils.getField(field, container);
}

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

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

/**
 * Finds all unused stubs for given mocks
 * 
 * @param mocks
 */
public List<Invocation> find(List<?> mocks) {
    List<Invocation> unused = new LinkedList<Invocation>();
    for (Object mock : mocks) {
        InternalMockHandler<Object> handler = new MockUtil().getMockHandler(mock);
        List<StubbedInvocationMatcher> fromSingleMock = handler.getInvocationContainer().getStubbedInvocations();
        for(StubbedInvocationMatcher s : fromSingleMock) {
            if (!s.wasUsed()) {
                 unused.add(s.getInvocation());
            }
        }
    }
    return unused;
}

/**
 * gets all invocations from mocks. Invocations are ordered earlier first. 
 * 
 * @param mocks mocks
 * @return invocations
 */
public List<Invocation> find(List<?> mocks) {
    Set<Invocation> invocationsInOrder = new TreeSet<Invocation>(new SequenceNumberComparator());
    for (Object mock : mocks) {
        InternalMockHandler<Object> handler = new MockUtil().getMockHandler(mock);
        List<Invocation> fromSingleMock = handler.getInvocationContainer().getInvocations();
        invocationsInOrder.addAll(fromSingleMock);
    }

    return new LinkedList<Invocation>(invocationsInOrder);
}

private Object deepStub(InvocationOnMock invocation, GenericMetadataSupport returnTypeGenericMetadata) throws Throwable {
    InternalMockHandler<Object> handler = new MockUtil().getMockHandler(invocation.getMock());
    InvocationContainerImpl container = (InvocationContainerImpl) handler.getInvocationContainer();

      // matches invocation for verification
      for (StubbedInvocationMatcher stubbedInvocationMatcher : container.getStubbedInvocations()) {
        if(container.getInvocationForStubbing().matches(stubbedInvocationMatcher.getInvocation())) {
            return stubbedInvocationMatcher.answer(invocation);
        }
}

      // record deep stub answer
      return recordDeepStubAnswer(newDeepStubMock(returnTypeGenericMetadata), container);
  }

public InternalMockHandler create(MockCreationSettings settings) {
    InternalMockHandler handler = new MockHandlerImpl(settings);
    InternalMockHandler nullResultGuardian = new NullResultGuardian(handler);
    InternalMockHandler notifier = new InvocationNotifierHandler(nullResultGuardian, settings);

    return notifier;
}

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

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);
}

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());
    }
}

@Test
//see issue 331
public void handle_result_must_not_be_null_for_primitives() throws Throwable {
    //given:
    MockCreationSettings settings = (MockCreationSettings) new MockSettingsImpl().defaultAnswer(new Returns(null));
    InternalMockHandler handler = new MockHandlerFactory().create(settings);

    mock.intReturningMethod();
    Invocation invocation = super.getLastInvocation();

    //when:
    Object result = handler.handle(invocation);

    //then null value is not a valid result for a primitive
    assertNotNull(result);
    assertEquals(0, result);
}

@Test
//see issue 331
public void valid_handle_result_is_permitted() throws Throwable {
    //given:
    MockCreationSettings settings = (MockCreationSettings) new MockSettingsImpl().defaultAnswer(new Returns(123));
    InternalMockHandler handler = new MockHandlerFactory().create(settings);

    mock.intReturningMethod();
    Invocation invocation = super.getLastInvocation();

    //when:
    Object result = handler.handle(invocation);

    //then
    assertEquals(123, result);
}

public PowerMockMethodInterceptorFilter(InternalMockHandler handler,
        MockCreationSettings mockSettings) {
    super(handler, mockSettings);
}

public MethodInterceptorFilter(InternalMockHandler handler, MockCreationSettings mockSettings) {
    this.handler = handler;
    this.mockSettings = mockSettings;
}

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());
}

public InvocationNotifierHandler(InternalMockHandler<T> mockHandler, MockCreationSettings settings) {
    this.mockHandler = mockHandler;
    this.invocationListeners = settings.getInvocationListeners();
}

public NullResultGuardian(InternalMockHandler delegate) {
    this.delegate = delegate;
}

public MethodInterceptorFilter(InternalMockHandler handler, MockCreationSettings mockSettings) {
    this.handler = handler;
    this.mockSettings = mockSettings;
}

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());
}