* the type is irrelevant at runtime.
     */
    mock = mock(Cache.class);
    forward =
        new ForwardingCache<String, Boolean>() {
          @Override
          protected Cache<String, Boolean> delegate() {
            return mock;
          }
        };
  }

  public void testGetIfPresent() throws ExecutionException {
    when(mock.getIfPresent("key")).thenReturn(Boolean.TRUE);

    PrimitiveSink primitiveSink = mock(PrimitiveSink.class);
    Funnels.byteArrayFunnel().funnel(new byte[] {4, 3, 2, 1}, primitiveSink);
    verify(primitiveSink).putBytes(new byte[] {4, 3, 2, 1});
  }

  public void testForBytes_null() {
    assertNullsThrowException(Funnels.byteArrayFunnel());
  }

  public void testForStrings() {
    PrimitiveSink primitiveSink = mock(PrimitiveSink.class);

     * the type is irrelevant at runtime.
     */
    mock = mock(LoadingCache.class);
    forward =
        new ForwardingLoadingCache<String, Boolean>() {
          @Override
          protected LoadingCache<String, Boolean> delegate() {
            return mock;
          }
        };
  }

  public void testGet() throws ExecutionException {
    when(mock.get("key")).thenReturn(Boolean.TRUE);

    private final ProjectBuilder projectBuilder = mock(ProjectBuilder.class);
    private final MavenSession session = mock(MavenSession.class);
    private final MavenExecutionRequest mavenExecutionRequest = mock(MavenExecutionRequest.class);

    private final ProjectsSelector projectsSelector = new DefaultProjectsSelector(projectBuilder);

    // Not using mocks for these strategies - a mock would just copy the actual implementation.

        rsession.setLocalRepositoryManager(system.newLocalRepositoryManager(rsession, localRepo));

        rsession.setTransferListener(Mockito.mock(TransferListener.class));
        rsession.setRepositoryListener(Mockito.mock(RepositoryListener.class));

        DefaultMavenExecutionRequest request = new DefaultMavenExecutionRequest();

  private final ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  @SuppressWarnings("DoNotMock")
  @Override
  protected void setUp() throws Exception {
    super.setUp();
    hasher = mock(Hasher.class);
    hashFunction = mock(HashFunction.class);

    when(hashFunction.newHasher()).thenReturn(hasher);
  }

  public void testWrite_putSingleByte() throws Exception {
    int b = 'q';

     * the type is irrelevant at runtime.
     */
    mock = mock(LoadingCache.class);
    forward =
        new ForwardingLoadingCache<String, Boolean>() {
          @Override
          protected LoadingCache<String, Boolean> delegate() {
            return mock;
          }
        };
  }

  public void testGet() throws ExecutionException {
    when(mock.get("key")).thenReturn(Boolean.TRUE);

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.repository.legacy;

import org.apache.maven.wagon.providers.file.FileWagon;

/**
 * Mock of a Wagon for testing
 *
 */
public class WagonMock extends FileWagon {

    /**
     * A field that can be configured in the Wagon
     *
     * @component.configuration default="configurableField"
     */

    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);
    assertFalse(testExecutor.awaitTermination(10, TimeUnit.MILLISECONDS));
    mock.assertLastMethodCalled("awaitTermination");
    assertFalse(testExecutor.isTerminated());
    mock.assertLastMethodCalled("isTerminated");
    assertFalse(testExecutor.isShutdown());
    mock.assertLastMethodCalled("isShutdown");

  }

  @AndroidIncompatible // Mocking ExecutorService is forbidden there. TODO(b/218700094): Don't mock.
  public void testGetExitingExecutorService_executorDelegatesToOriginal() {
    TestApplication application = new TestApplication();
    ThreadPoolExecutor executor = mock(ThreadPoolExecutor.class);
    ThreadFactory threadFactory = mock(ThreadFactory.class);
    when(executor.getThreadFactory()).thenReturn(threadFactory);