Java 类org.mockito.internal.stubbing.defaultanswers.ForwardsInvocations 实例源码

@Test
public void testCheckRequest_mGitHubService() throws Exception {
    GitHubService service;
    {
        service = mIsolateEnvRule.mTestMyModule.mGitHubService;
        service = mock(GitHubService.class, new ForwardsInvocations(service));
        mIsolateEnvRule.mTestMyModule.mGitHubService = service;
    }

    mActivityTestRule.launchActivity(null);
    verify(service).listRepos(eq("cattaka"));
}

@Before public void setUp() {
  // We cannot spy the Dagger‡ component as it's final, so we wrap it in a mock that delegates to it.
  // We want to test both that the method is called (mockito) and that everything actually works (dagger).
  SimpleComponent realComponent = DaggerSimpleComponentTest_SimpleComponent.create();
  this.component = mock(SimpleComponent.class, new ForwardsInvocations(realComponent));
  graph = new BulletSimpleComponentTest_SimpleComponent(component);
}

@Before public void setUp() {
  // We cannot spy the Dagger‡ component as it's final, so we wrap it in a mock that delegates to it.
  // We want to test both that the method is called (mockito) and that everything actually works (dagger).
  SimpleComponent realComponent = DaggerMembersInjectionTest_SimpleComponent.create();
  this.component = mock(SimpleComponent.class, new ForwardsInvocations(realComponent));
  graph = new BulletMembersInjectionTest_SimpleComponent(component);
}

@Before public void setUp() {
  // We cannot spy the Dagger‡ component as it's final, so we wrap it in a mock that delegates to it.
  // We want to test both that the method is called (mockito) and that everything actually works (dagger).
  SimpleSubcomponent realComponent = DaggerSimpleSubcomponentTest_SimpleComponent.create().subcomponent();
  this.component = mock(SimpleSubcomponent.class, new ForwardsInvocations(realComponent));
  graph = new BulletSimpleSubcomponentTest_SimpleSubcomponent(component);
}

/**
 * An answer that directly forwards the calls to the delegate.
 * <p>
 * Useful for spies or partial mocks of objects that are difficult to mock
 * or spy using the usual spy API. Possible use cases:
 * <ul>
 *     <li>Final classes but with an interface</li>
 *     <li>Already custom proxied object</li>
 *     <li>Special objects with a finalize method, i.e. to avoid executing it 2 times</li>
 * </ul>
 * For more details including the use cases reported by users take a look at
 * <a link="http://code.google.com/p/mockito/issues/detail?id=145">issue 145</a>.
 * <p>
 * The difference with the regular spy:
 * <ul>
 *   <li>
 *     The regular spy ({@link Mockito#spy(Object)}) contains <strong>all</strong> state from the spied instance
 *     and the methods are invoked on the spy. The spied instance is only used at mock creation to copy the state from.
 *     If you call a method on a regular spy and it internally calls other methods on this spy, those calls are remembered
 *     for verifications, and they can be effectively stubbed.
 *   </li>
 *   <li>
 *     The mock that delegates simply delegates all methods to the delegate.
 *     The delegate is used all the time as methods are delegated onto it.
 *     If you call a method on a mock that delegates and it internally calls other methods on this mock,
 *     those calls are <strong>not</strong> remembered for verifications, stubbing does not have effect on them, too.
 *     Mock that delegates is less powerful than the regular spy but it is useful when the regular spy cannot be created.
 *   </li>
 * </ul>
 * An example with a final class that we want to delegate to:
 * <p>
 * <pre class="code"><code class="java">
 *   final class DontYouDareToMockMe implements list { ... }
 *
 *   DontYouDareToMockMe awesomeList = new DontYouDareToMockMe();
 *
 *   List mock = mock(List.class, delegatesTo(awesomeList));
 * </code></pre>
 *
 * <p>
 * This feature suffers from the same drawback as the spy.
 * The mock will call the delegate if you use regular when().then() stubbing style.
 * Since the real implementation is called this might have some side effects.
 * Therefore you should to use the doReturn|Throw|Answer|CallRealMethod stubbing style. Example:
 *
 * <pre class="code"><code class="java">
 *   List listWithDelegate = mock(List.class, AdditionalAnswers.delegatesTo(awesomeList));
 *
 *   //Impossible: real method is called so listWithDelegate.get(0) throws IndexOutOfBoundsException (the list is yet empty)
 *   when(listWithDelegate.get(0)).thenReturn("foo");
 *
 *   //You have to use doReturn() for stubbing
 *   doReturn("foo").when(listWithDelegate).get(0);
 * </code></pre>
 *
 * @param delegate The delegate to forward calls to.
 * @return the answer
 *
 * @since 1.9.5
 */
public static <T> Answer<T> delegatesTo(Object delegate) {
    return (Answer<T>) new ForwardsInvocations(delegate);
}