/* | |
* Copyright (c) 2007 Mockito contributors | |
* This program is made available under the terms of the MIT License. | |
*/ | |
package org.mockito.internal; | |
import java.util.Arrays; | |
import java.util.List; | |
import org.mockito.InOrder; | |
import org.mockito.MockSettings; | |
import org.mockito.MockingDetails; | |
import org.mockito.exceptions.Reporter; | |
import org.mockito.exceptions.misusing.NotAMockException; | |
import org.mockito.internal.creation.MockSettingsImpl; | |
import org.mockito.internal.invocation.finder.VerifiableInvocationsFinder; | |
import org.mockito.internal.progress.IOngoingStubbing; | |
import org.mockito.internal.progress.MockingProgress; | |
import org.mockito.internal.progress.ThreadSafeMockingProgress; | |
import org.mockito.internal.stubbing.InvocationContainer; | |
import org.mockito.internal.stubbing.OngoingStubbingImpl; | |
import org.mockito.internal.stubbing.StubberImpl; | |
import org.mockito.internal.util.DefaultMockingDetails; | |
import org.mockito.internal.util.MockUtil; | |
import org.mockito.internal.verification.MockAwareVerificationMode; | |
import org.mockito.internal.verification.VerificationDataImpl; | |
import org.mockito.internal.verification.VerificationModeFactory; | |
import org.mockito.internal.verification.api.InOrderContext; | |
import org.mockito.internal.verification.api.VerificationDataInOrder; | |
import org.mockito.internal.verification.api.VerificationDataInOrderImpl; | |
import org.mockito.invocation.Invocation; | |
import org.mockito.mock.MockCreationSettings; | |
import org.mockito.stubbing.Answer; | |
import org.mockito.stubbing.DeprecatedOngoingStubbing; | |
import org.mockito.stubbing.OngoingStubbing; | |
import org.mockito.stubbing.Stubber; | |
import org.mockito.stubbing.VoidMethodStubbable; | |
import org.mockito.verification.VerificationMode; | |
@SuppressWarnings("unchecked") | |
public class MockitoCore { | |
private final Reporter reporter = new Reporter(); | |
private final MockUtil mockUtil = new MockUtil(); | |
private final MockingProgress mockingProgress = new ThreadSafeMockingProgress(); | |
public boolean isTypeMockable(Class<?> typeToMock) { | |
return mockUtil.isTypeMockable(typeToMock); | |
} | |
public <T> T mock(Class<T> typeToMock, MockSettings settings) { | |
if (!MockSettingsImpl.class.isInstance(settings)) { | |
throw new IllegalArgumentException( | |
"Unexpected implementation of '" + settings.getClass().getCanonicalName() + "'\n" | |
+ "At the moment, you cannot provide your own implementations that class."); | |
} | |
MockSettingsImpl impl = MockSettingsImpl.class.cast(settings); | |
MockCreationSettings<T> creationSettings = impl.confirm(typeToMock); | |
T mock = mockUtil.createMock(creationSettings); | |
mockingProgress.mockingStarted(mock, typeToMock); | |
return mock; | |
} | |
public IOngoingStubbing stub() { | |
IOngoingStubbing stubbing = mockingProgress.pullOngoingStubbing(); | |
if (stubbing == null) { | |
mockingProgress.reset(); | |
reporter.missingMethodInvocation(); | |
} | |
return stubbing; | |
} | |
public <T> DeprecatedOngoingStubbing<T> stub(T methodCall) { | |
mockingProgress.stubbingStarted(); | |
return (DeprecatedOngoingStubbing) stub(); | |
} | |
public <T> OngoingStubbing<T> when(T methodCall) { | |
mockingProgress.stubbingStarted(); | |
return (OngoingStubbing) stub(); | |
} | |
public <T> T verify(T mock, VerificationMode mode) { | |
if (mock == null) { | |
reporter.nullPassedToVerify(); | |
} else if (!mockUtil.isMock(mock)) { | |
reporter.notAMockPassedToVerify(mock.getClass()); | |
} | |
mockingProgress.verificationStarted(new MockAwareVerificationMode(mock, mode)); | |
return mock; | |
} | |
public <T> void reset(T ... mocks) { | |
mockingProgress.validateState(); | |
mockingProgress.reset(); | |
mockingProgress.resetOngoingStubbing(); | |
for (T m : mocks) { | |
mockUtil.resetMock(m); | |
} | |
} | |
public void verifyNoMoreInteractions(Object... mocks) { | |
assertMocksNotEmpty(mocks); | |
mockingProgress.validateState(); | |
for (Object mock : mocks) { | |
try { | |
if (mock == null) { | |
reporter.nullPassedToVerifyNoMoreInteractions(); | |
} | |
InvocationContainer invocations = mockUtil.getMockHandler(mock).getInvocationContainer(); | |
VerificationDataImpl data = new VerificationDataImpl(invocations, null); | |
VerificationModeFactory.noMoreInteractions().verify(data); | |
} catch (NotAMockException e) { | |
reporter.notAMockPassedToVerifyNoMoreInteractions(); | |
} | |
} | |
} | |
public void verifyNoMoreInteractionsInOrder(List<Object> mocks, InOrderContext inOrderContext) { | |
mockingProgress.validateState(); | |
VerifiableInvocationsFinder finder = new VerifiableInvocationsFinder(); | |
VerificationDataInOrder data = new VerificationDataInOrderImpl(inOrderContext, finder.find(mocks), null); | |
VerificationModeFactory.noMoreInteractions().verifyInOrder(data); | |
} | |
private void assertMocksNotEmpty(Object[] mocks) { | |
if (mocks == null || mocks.length == 0) { | |
reporter.mocksHaveToBePassedToVerifyNoMoreInteractions(); | |
} | |
} | |
public InOrder inOrder(Object... mocks) { | |
if (mocks == null || mocks.length == 0) { | |
reporter.mocksHaveToBePassedWhenCreatingInOrder(); | |
} | |
for (Object mock : mocks) { | |
if (mock == null) { | |
reporter.nullPassedWhenCreatingInOrder(); | |
} else if (!mockUtil.isMock(mock)) { | |
reporter.notAMockPassedWhenCreatingInOrder(); | |
} | |
} | |
return new InOrderImpl(Arrays.asList(mocks)); | |
} | |
public Stubber doAnswer(Answer answer) { | |
mockingProgress.stubbingStarted(); | |
mockingProgress.resetOngoingStubbing(); | |
return new StubberImpl().doAnswer(answer); | |
} | |
public <T> VoidMethodStubbable<T> stubVoid(T mock) { | |
InternalMockHandler<T> handler = mockUtil.getMockHandler(mock); | |
mockingProgress.stubbingStarted(); | |
return handler.voidMethodStubbable(mock); | |
} | |
public void validateMockitoUsage() { | |
mockingProgress.validateState(); | |
} | |
/** | |
* For testing purposes only. Is not the part of main API. | |
* @return last invocation | |
*/ | |
public Invocation getLastInvocation() { | |
OngoingStubbingImpl ongoingStubbing = ((OngoingStubbingImpl) mockingProgress.pullOngoingStubbing()); | |
List<Invocation> allInvocations = ongoingStubbing.getRegisteredInvocations(); | |
return allInvocations.get(allInvocations.size()-1); | |
} | |
public Object[] ignoreStubs(Object... mocks) { | |
for (Object m : mocks) { | |
InvocationContainer invocationContainer = new MockUtil().getMockHandler(m).getInvocationContainer(); | |
List<Invocation> ins = invocationContainer.getInvocations(); | |
for (Invocation in : ins) { | |
if (in.stubInfo() != null) { | |
in.ignoreForVerification(); | |
} | |
} | |
} | |
return mocks; | |
} | |
public MockingDetails mockingDetails(Object toInspect) { | |
return new DefaultMockingDetails(toInspect, new MockUtil()); | |
} | |
} |