import org.mockito.invocation.Invocation; //导入依赖的package包/类
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
        throws Throwable {
    if (objectMethodsGuru.isEqualsMethod(method)) {
        return proxy == args[0];
    } else if (objectMethodsGuru.isHashCodeMethod(method)) {
        return hashCodeForMock(proxy);
    } else if (acrossJVMSerializationFeature.isWriteReplace(method)) {
        return acrossJVMSerializationFeature.writeReplace(proxy);
    }
    
    MockitoMethodProxy mockitoMethodProxy = createMockitoMethodProxy(methodProxy);
    new CGLIBHacker().setMockitoNamingPolicy(methodProxy);
    
    MockitoMethod mockitoMethod = createMockitoMethod(method);
    
    CleanTraceRealMethod realMethod = new CleanTraceRealMethod(mockitoMethodProxy);
    Invocation invocation = new InvocationImpl(proxy, mockitoMethod, args, SequenceNumber.next(), realMethod);
    return handler.handle(invocation);
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
public void verify(VerificationData verificationData) {
  List<Invocation> invocations = verificationData.getAllInvocations();
  InvocationMatcher invocationMatcher = verificationData.getWanted();

  if (invocations == null || invocations.isEmpty()) {
    throw new MockitoException(
        "\nNo interactions with "
            + invocationMatcher.getInvocation().getMock()
            + " mock so far");
  }
  Invocation invocation = invocations.get(invocations.size() - 1);

  if (!invocationMatcher.matches(invocation)) {
    throw new MockitoException("\nWanted but not invoked:\n" + invocationMatcher);
  }
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
/**
 * similar means the same method name, same mock, unverified 
 * and: if arguments are the same cannot be overloaded
 */
public boolean hasSimilarMethod(Invocation candidate) {
    String wantedMethodName = getMethod().getName();
    String currentMethodName = candidate.getMethod().getName();
    
    final boolean methodNameEquals = wantedMethodName.equals(currentMethodName);
    final boolean isUnverified = !candidate.isVerified();
    final boolean mockIsTheSame = getInvocation().getMock() == candidate.getMock();
    final boolean methodEquals = hasSameMethod(candidate);

    if (!methodNameEquals || !isUnverified || !mockIsTheSame) {
        return false;
    }

    final boolean overloadedButSameArgs = !methodEquals && safelyArgumentsMatch(candidate.getArguments());

    return !overloadedButSameArgs;
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
public boolean hasSameMethod(Invocation candidate) {
    //not using method.equals() for 1 good reason:
    //sometimes java generates forwarding methods when generics are in play see JavaGenericsForwardingMethodsTest
    Method m1 = invocation.getMethod();
    Method m2 = candidate.getMethod();
    
    if (m1.getName() != null && m1.getName().equals(m2.getName())) {
    	/* Avoid unnecessary cloning */
    	Class[] params1 = m1.getParameterTypes();
    	Class[] params2 = m2.getParameterTypes();
    	if (params1.length == params2.length) {
    	    for (int i = 0; i < params1.length; i++) {
    		if (params1[i] != params2[i])
    		    return false;
    	    }
    	    return true;
    	}
    }
    return false;
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
public void captureArgumentsFrom(Invocation invocation) {
    for (int position = 0; position < matchers.size(); position++) {
        Matcher m = matchers.get(position);
        if (m instanceof CapturesArguments && invocation.getRawArguments().length > position) {
            //TODO SF - this whole lot can be moved captureFrom implementation
            if(isVariableArgument(invocation, position) && isVarargMatcher(m)) {
                Object array = invocation.getRawArguments()[position];
                for (int i = 0; i < Array.getLength(array); i++) {
                    ((CapturesArguments) m).captureFrom(Array.get(array, i));
                }
                //since we've captured all varargs already, it does not make sense to process other matchers.
                return;
            } else {
                ((CapturesArguments) m).captureFrom(invocation.getRawArguments()[position]);
            }
        }
    }
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
@Test
public void should_get_results_for_methods_stub_only() throws Throwable {
    invocationContainerImplStubOnly.setInvocationForPotentialStubbing(new InvocationMatcher(simpleMethod));
    invocationContainerImplStubOnly.addAnswer(new Returns("simpleMethod"));

    Invocation differentMethod = new InvocationBuilder().differentMethod().toInvocation();
    invocationContainerImplStubOnly.setInvocationForPotentialStubbing(new InvocationMatcher(differentMethod));
    invocationContainerImplStubOnly.addAnswer(new ThrowsException(new MyException()));

    assertEquals("simpleMethod", invocationContainerImplStubOnly.answerTo(simpleMethod));

    try {
        invocationContainerImplStubOnly.answerTo(differentMethod);
        fail();
    } catch (MyException e) {}
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
public Invocation findSimilarInvocation(List<Invocation> invocations, InvocationMatcher wanted) {
    Invocation firstSimilar = null;
    for (Invocation invocation : invocations) {
        if (!wanted.hasSimilarMethod(invocation)) {
            continue;
        }
        if (firstSimilar == null) {
            firstSimilar = invocation;
        }
        if (wanted.hasSameMethod(invocation)) {
            return invocation;
        }
    }
    
    return firstSimilar;
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
@Test
public void should_get_results_for_methods() throws Throwable {
    invocationContainerImpl.setInvocationForPotentialStubbing(new InvocationMatcher(simpleMethod));
    invocationContainerImpl.addAnswer(new Returns("simpleMethod"));

    Invocation differentMethod = new InvocationBuilder().differentMethod().toInvocation();
    invocationContainerImpl.setInvocationForPotentialStubbing(new InvocationMatcher(differentMethod));
    invocationContainerImpl.addAnswer(new ThrowsException(new MyException()));

    assertEquals("simpleMethod", invocationContainerImpl.answerTo(simpleMethod));

    try {
        invocationContainerImpl.answerTo(differentMethod);
        fail();
    } catch (MyException e) {}
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
@Test
public void shouldMarkInvocationsAsVerifiedInOrder() {
    //given
    InOrderContextImpl context = new InOrderContextImpl();
    InvocationMarker marker = new InvocationMarker();
    Invocation i = new InvocationBuilder().toInvocation();
    InvocationMatcher im = new InvocationBuilder().toInvocationMatcher();
    assertFalse(context.isVerified(i));
    assertFalse(i.isVerified());
    
    //when
    marker.markVerifiedInOrder(Arrays.asList(i), im, context);
    
    //then
    assertTrue(context.isVerified(i));
    assertTrue(i.isVerified());
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
private static void verifySameInvocation(Invocation expectedInvocation, Invocation actualInvocation, InvocationArgumentsAdapter... argumentAdapters) {
	System.out.println(expectedInvocation);
	System.out.println(actualInvocation);
	assertThat(expectedInvocation.getMethod(), is(equalTo(actualInvocation.getMethod())));
	Object[] expectedArguments = getInvocationArguments(expectedInvocation, argumentAdapters);
	Object[] actualArguments = getInvocationArguments(actualInvocation, argumentAdapters);
	assertThat(expectedArguments, is(equalTo(actualArguments)));
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
private static Object[] getInvocationArguments(Invocation invocation, InvocationArgumentsAdapter... argumentAdapters) {
	Object[] arguments = invocation.getArguments();
	for (InvocationArgumentsAdapter adapter : argumentAdapters) {
		arguments = adapter.adaptArguments(arguments);
	}
	return arguments;
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
public InvocationMatcher bindMatchers(ArgumentMatcherStorage argumentMatcherStorage, final Invocation invocation) {
    List<LocalizedMatcher> lastMatchers = argumentMatcherStorage.pullLocalizedMatchers();
    validateMatchers(invocation, lastMatchers);

    final InvocationMatcher invocationWithMatchers = new InvocationMatcher(invocation, (List<Matcher>)(List) lastMatchers) {
        @Override
        public String toString() {
            return invocation.toString();
        }
    };
    return invocationWithMatchers;
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
private void validateMatchers(Invocation invocation, List<LocalizedMatcher> lastMatchers) {
    if (!lastMatchers.isEmpty()) {
        int recordedMatchersSize = lastMatchers.size();
        int expectedMatchersSize = invocation.getArguments().length;
        if (expectedMatchersSize != recordedMatchersSize) {
            new Reporter().invalidUseOfMatchers(expectedMatchersSize, lastMatchers);
        }
    }
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
/**
 * Build the invocation
 *
 * If the method was not specified, use IMethods methods.
 *
 * @return invocation
 */
public Invocation toInvocation() {
    if (method == null) {
        if (argTypes == null) {
            argTypes = new LinkedList<Class<?>>();
            for (Object arg : args) {
                if (arg == null) {
                    argTypes.add(Object.class);
                } else {
                    argTypes.add(arg.getClass());
                }
            }
        }

        try {
            method = MethodsImpl.class.getMethod(methodName, argTypes.toArray(new Class[argTypes.size()]));
        } catch (Exception e) {
            throw new RuntimeException("builder only creates invocations of IMethods interface", e);
        }
    }
    
    Invocation i = new InvocationImpl(mock, new SerializableMethod(method), args, sequenceNumber, null);
    if (verified) {
        i.markVerified();
    }
    return i;
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
@Test
public void allConfigurationGettersShouldBeCalled() {
  plugin = new ValidateMojo(configuration);

  List<Method> invokedMethods = new ArrayList<Method>();
  for (Invocation invocation : mockingDetails(configuration).getInvocations()) {
    invokedMethods.add(invocation.getMethod());
  }

  for (Method method : L10nValidationConfiguration.class.getDeclaredMethods()) {
    if (method.getName().startsWith("get")) {
      assertThat("A getter was not called", invokedMethods, hasItem(method));
    }
  }
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
@Test
public void shouldReturnAllChunksWhenWantedCountDoesntMatch() throws Exception {
    Invocation simpleMethodInvocationThree = new InvocationBuilder().mock(mock).toInvocation();
    invocations.add(simpleMethodInvocationThree);
    
    List<Invocation> chunk = finder.findMatchingChunk(invocations, new InvocationMatcher(simpleMethodInvocation), 1, context);
    assertThat(chunk, hasExactlyInOrder(simpleMethodInvocation, simpleMethodInvocationTwo, simpleMethodInvocationThree));
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
@Test
public void shouldKnowWhenVarargsMatch() {
    //given
    mock.varargs("1", "2", "3");
    Invocation invocation = getLastInvocation();
    InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, (List) asList(new Equals("1"), Any.ANY, new InstanceOf(String.class)));

    //when
    boolean match = comparator.argumentsMatch(invocationMatcher, invocation);

    //then
    assertTrue(match);
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
@Test  // like using several time the captor in the vararg
public void should_capture_arguments_when_args_count_does_NOT_match() throws Exception {
    //given
    mock.varargs();
    Invocation invocation = getLastInvocation();

    //when
    InvocationMatcher invocationMatcher = new InvocationMatcher(invocation, (List) asList(new LocalizedMatcher(AnyVararg.ANY_VARARG)));

    //then
    invocationMatcher.captureArgumentsFrom(invocation);
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
public SmartPrinter(InvocationMatcher wanted, Invocation actual, Integer ... indexesOfMatchersToBeDescribedWithExtraTypeInfo) {
    PrintSettings printSettings = new PrintSettings();
    printSettings.setMultiline(wanted.toString().contains("\n") || actual.toString().contains("\n"));
    printSettings.setMatchersToBeDescribedWithExtraTypeInfo(indexesOfMatchersToBeDescribedWithExtraTypeInfo);
    
    this.wanted = printSettings.print(wanted);
    this.actual = printSettings.print(actual);
}
 

import org.mockito.invocation.Invocation; //导入依赖的package包/类
@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);
}