Java 类org.mockito.invocation.InvocationOnMock 实例源码

private Answer<HttpResponse> createOkResponseWithCookie() {
    return new Answer<HttpResponse>() {
        @Override
        public HttpResponse answer(InvocationOnMock invocation) throws Throwable {
            HttpContext context = (HttpContext) invocation.getArguments()[1];
            if (context.getAttribute(ClientContext.COOKIE_STORE) != null) {
                BasicCookieStore cookieStore =
                        (BasicCookieStore) context.getAttribute(ClientContext.COOKIE_STORE);
                BasicClientCookie cookie = new BasicClientCookie("cookie", "meLikeCookie");
                cookieStore.addCookie(cookie);
            }

            return OK_200_RESPONSE;
        }
    };
}

@Test
public void testSendMessageSync_Success() throws InterruptedException, RemotingException, MQBrokerException {
    doAnswer(new Answer() {
        @Override public Object answer(InvocationOnMock mock) throws Throwable {
            RemotingCommand request = mock.getArgument(1);
            return createSuccessResponse(request);
        }
    }).when(remotingClient).invokeSync(anyString(), any(RemotingCommand.class), anyLong());

    SendMessageRequestHeader requestHeader = createSendMessageRequestHeader();

    SendResult sendResult = mqClientAPI.sendMessage(brokerAddr, brokerName, msg, requestHeader,
        3 * 1000, CommunicationMode.SYNC, new SendMessageContext(), defaultMQProducerImpl);

    assertThat(sendResult.getSendStatus()).isEqualTo(SendStatus.SEND_OK);
    assertThat(sendResult.getOffsetMsgId()).isEqualTo("123");
    assertThat(sendResult.getQueueOffset()).isEqualTo(123L);
    assertThat(sendResult.getMessageQueue().getQueueId()).isEqualTo(1);
}

@Override
public GetReplicaVisibleLengthResponseProto answer(
    InvocationOnMock invocation) throws IOException {
  Object args[] = invocation.getArguments();
  assertEquals(2, args.length);
  GetReplicaVisibleLengthRequestProto req = 
      (GetReplicaVisibleLengthRequestProto) args[1];
  Set<TokenIdentifier> tokenIds = UserGroupInformation.getCurrentUser()
      .getTokenIdentifiers();
  assertEquals("Only one BlockTokenIdentifier expected", 1, tokenIds.size());
  long result = 0;
  for (TokenIdentifier tokenId : tokenIds) {
    BlockTokenIdentifier id = (BlockTokenIdentifier) tokenId;
    LOG.info("Got: " + id.toString());
    assertTrue("Received BlockTokenIdentifier is wrong", ident.equals(id));
    sm.checkAccess(id, null, PBHelper.convert(req.getBlock()),
        BlockTokenSecretManager.AccessMode.WRITE);
    result = id.getBlockId();
  }
  return GetReplicaVisibleLengthResponseProto.newBuilder()
      .setLength(result).build();
}

@Test
public void testSuccessfulEnqueueReportsResultToTheCallback() throws Exception {
    Endpoint endpoint = new Endpoint(MOCK_HOST, MOCK_PORT);
    final Connection connection = createDummyConnection(endpoint, MOCK_EMPTY_ARRAY_RESPONSE);
    Request request = RequestUtils.getUserInfoRequest(endpoint);
    mockConnection(connection);

    final RealCall call = getMockRealCall(request, executor);

    Callback callback = mock(Callback.class);
    when(executor.submit(any(Runnable.class))).thenAnswer(new Answer<Object>() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
            Object[] args = invocation.getArguments();
            Runnable runnable = (Runnable) args[0];
            runnable.run();
            return new FutureTask<Void>(runnable, null);
        }
    });

    call.enqueue(callback);

    verify(callback).onResponse(eq(call), notNull(Response.class));
    verify(callback, never()).onFailure(eq(call), notNull(IOException.class));
}

private void respondToFetchEnvelopesWithMessage(final Message message) throws MessagingException {
    doAnswer(new Answer() {
        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            FetchProfile fetchProfile = (FetchProfile) invocation.getArguments()[1];
            if (invocation.getArguments()[2] != null) {
                MessageRetrievalListener listener = (MessageRetrievalListener) invocation.getArguments()[2];
                if (fetchProfile.contains(FetchProfile.Item.ENVELOPE)) {
                    listener.messageStarted("UID", 1, 1);
                    listener.messageFinished(message, 1, 1);
                    listener.messagesFinished(1);
                }
            }
            return null;
        }
    }).when(remoteFolder).fetch(any(List.class), any(FetchProfile.class), any(MessageRetrievalListener.class));
}

@SuppressWarnings({"unchecked", "rawtypes"})
private void initEventHandlersInterception() {
    doAnswer(new Answer<Void>() {

        final EventType<StateChangeEventHandler, StateChangeEventTypes> STATE_CHANGED_TYPE = StateChangeEvent.getType(OUTCOME_STATE_CHANGED);
        final EventType<PlayerEventHandler, PlayerEventTypes> PAGE_UNLOADED_TYPE = PlayerEvent.getType(PlayerEventTypes.PAGE_UNLOADED);
        final EventType<PlayerEventHandler, PlayerEventTypes> TEST_PAGE_LOADED_TYPE = PlayerEvent.getType(PlayerEventTypes.TEST_PAGE_LOADED);

        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            EventType type = (EventType) invocation.getArguments()[0];
            Object handler = invocation.getArguments()[1];

            if (handler instanceof StateChangeEventHandler && type == STATE_CHANGED_TYPE) {
                stateChangedHandler = (StateChangeEventHandler) handler;
            } else if (handler instanceof PlayerEventHandler && type == PAGE_UNLOADED_TYPE) {
                pageUnloadedhandler = (PlayerEventHandler) handler;
            } else if (handler instanceof PlayerEventHandler && type == TEST_PAGE_LOADED_TYPE) {
                testPageLoadedHandler = (PlayerEventHandler) handler;
            }

            return null;
        }
    }).when(eventsBus).addHandler(any(EventType.class), any(EventHandler.class), any(EventScope.class));
}

@Test
public void testAddAnswerToQuestion_firstAnswer_shouldEnableQuestionAndMarkItAsCorrect() {
    when(answerService.countAnswersInQuestion(question)).thenReturn(0);
    question.setIsValid(false);
    question.setCorrectAnswer(null);
    Answer answer = new Answer();
    answer.setId(1l);

    when(answerService.save(any(Answer.class))).thenAnswer(new org.mockito.stubbing.Answer<Answer>() {
        @Override
        public Answer answer(InvocationOnMock invocation) throws Throwable {
            Object[] args = invocation.getArguments();
            return (Answer) args[0];
        }
    });

    service.addAnswerToQuestion(answer, question);

    assertTrue(question.getIsValid());
    assertEquals(answer, question.getCorrectAnswer());
    verify(answerService, times(1)).save(answer);
    verify(questionRepository, times(2)).save(question);
}

@Before
public void setUp() throws Exception {
    initMocks(this);
    kubernetesAgentInstances = new KubernetesAgentInstances(mockedKubernetesClientFactory);
    when(mockedKubernetesClientFactory.kubernetes(any())).thenReturn(mockKubernetesClient);

    when(pods.inNamespace(Constants.KUBERNETES_NAMESPACE_KEY)).thenReturn(pods);

    when(pods.create(any())).thenAnswer(new Answer<Pod>() {
        @Override
        public Pod answer(InvocationOnMock invocation) throws Throwable {
            Object[] args = invocation.getArguments();
            return (Pod) args[0];
        }
    });

    when(pods.list()).thenReturn(new PodList());
    when(mockKubernetesClient.pods()).thenReturn(pods);

    createAgentRequest = CreateAgentRequestMother.defaultCreateAgentRequest();
    settings = PluginSettingsMother.defaultPluginSettings();
}

@Test
public void shouldBulkLoadManyFamilyHLogEvenWhenTableNameNamespaceSpecified() throws IOException {
  when(log.append(any(HTableDescriptor.class), any(HRegionInfo.class),
          any(WALKey.class), argThat(bulkLogWalEditType(WALEdit.BULK_LOAD)),
          any(boolean.class))).thenAnswer(new Answer() {
    public Object answer(InvocationOnMock invocation) {
      WALKey walKey = invocation.getArgumentAt(2, WALKey.class);
      MultiVersionConcurrencyControl mvcc = walKey.getMvcc();
      if (mvcc != null) {
        MultiVersionConcurrencyControl.WriteEntry we = mvcc.begin();
        walKey.setWriteEntry(we);
      }
      return 01L;
    };
  });
  TableName tableName = TableName.valueOf("test", "test");
  testRegionWithFamiliesAndSpecifiedTableName(tableName, family1, family2)
      .bulkLoadHFiles(withFamilyPathsFor(family1, family2), false, null);
  verify(log).sync(anyLong());
}

private void setupSpySession(final List<String> capturedRequestSessionTokenList, final List<String> capturedResponseSessionTokenList, 
        RxDocumentClientImpl spyClient, final RxDocumentClientImpl origClient) throws DocumentClientException {

    Mockito.reset(spyClient);
    doAnswer(new Answer<Void>() {
        public Void answer(InvocationOnMock invocation) throws Throwable {
            Object[] args = invocation.getArguments();
            RxDocumentServiceRequest req = (RxDocumentServiceRequest) args[0];
            DocumentServiceResponse resp = (DocumentServiceResponse) args[1];

            capturedRequestSessionTokenList.add(req.getHeaders().get(HttpConstants.HttpHeaders.SESSION_TOKEN));
            capturedResponseSessionTokenList.add(resp.getResponseHeaders().get(HttpConstants.HttpHeaders.SESSION_TOKEN));

            origClient.captureSessionToken(req, resp);

            return null;
        }})
    .when(spyClient).captureSessionToken(Mockito.any(RxDocumentServiceRequest.class), Mockito.any(DocumentServiceResponse.class));
}

@Before
public void setUp() throws Exception {
  Glide.tearDown();

  RobolectricPackageManager pm = RuntimeEnvironment.getRobolectricPackageManager();
  ApplicationInfo info =
      pm.getApplicationInfo(RuntimeEnvironment.application.getPackageName(), 0);
  info.metaData = new Bundle();
  info.metaData.putString(SetupModule.class.getName(), "GlideModule");

  // Ensure that target's size ready callback will be called synchronously.
  target = mock(Target.class);
  imageView = new ImageView(RuntimeEnvironment.application);
  imageView.setLayoutParams(new ViewGroup.LayoutParams(100, 100));
  imageView.layout(0, 0, 100, 100);
  doAnswer(new CallSizeReady()).when(target).getSize(isA(SizeReadyCallback.class));

  Handler bgHandler = mock(Handler.class);
  when(bgHandler.post(isA(Runnable.class))).thenAnswer(new Answer<Boolean>() {
    @Override
    public Boolean answer(InvocationOnMock invocation) throws Throwable {
      Runnable runnable = (Runnable) invocation.getArguments()[0];
      runnable.run();
      return true;
    }
  });

  Lifecycle lifecycle = mock(Lifecycle.class);
  RequestManagerTreeNode treeNode = mock(RequestManagerTreeNode.class);
  requestManager = new RequestManager(Glide.get(getContext()), lifecycle, treeNode);
  requestManager.resumeRequests();
}

@Test
public void shouldNotifyClientsOnStateChanged_bothClients() {
    // given
    StateChangeEvent event = mockStateChangeEvent(true, false);
    doAnswer(new Answer<Void>() {

        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            EndHandler handler = (EndHandler) invocation.getArguments()[0];
            handler.onEnd();
            return null;
        }
    }).when(tutor).processUserInteraction(any(EndHandler.class));
    mediator.registerTutor(tutor);
    mediator.registerBonus(bonus);

    // when
    stateChangedHandler.onStateChange(event);

    // then
    InOrder inOrder = Mockito.inOrder(tutor, bonus);
    inOrder.verify(tutor).processUserInteraction(any(EndHandler.class));
    inOrder.verify(bonus).processUserInteraction();
}

private void mock_RLP_decode2_forMapOfHashesToLong() {
    // Plain list with first elements being the size
    // Sizes are 1 byte long
    // e.g., for list [a,b,c] and a.size = 5, b.size = 7, c.size = 4, then:
    // 03050704[a bytes][b bytes][c bytes]
    when(RLP.decode2(any(byte[].class))).then((InvocationOnMock invocation) -> {
        RLPList result = new RLPList();
        byte[] arg = invocation.getArgumentAt(0, byte[].class);
        // Even byte -> hash of 64 bytes with same char from byte
        // Odd byte -> long from byte
        for (int i = 0; i < arg.length; i++) {
            byte[] element;
            if (i%2 == 0) {
                element = Hex.decode(charNTimes((char) arg[i], 64));
            } else {
                element = new byte[]{arg[i]};
            }
            result.add(() -> element);
        }
        return new ArrayList<>(Arrays.asList(result));
    });
}

@Test
public void shouldCallPlayOrStopEntryOnPlayButtonClick() {
    // given
    String file = "test.mp3";
    Entry entry = mock(Entry.class);
    when(entry.getEntrySound()).thenReturn(file);

    doAnswer(new Answer<Void>() {
        @Override
        public Void answer(InvocationOnMock invocation) {
            clickHandler = (ClickHandler) invocation.getArguments()[0];
            return null;
        }
    }).when(explanationView).addEntryPlayButtonHandler(any(ClickHandler.class));

    // when
    testObj.init();
    testObj.processEntry(entry);
    clickHandler.onClick(null);

    // then
    verify(entryDescriptionSoundController).playOrStopEntrySound(entry.getEntrySound());
}

private void registerAvailableKubernetesDeploymentAfterCount(DeploymentSpec ds, int count) throws VmidcException {
    KubernetesDeployment unavailableK8sDeployment = Mockito.mock(KubernetesDeployment.class);
    when(unavailableK8sDeployment.getAvailableReplicaCount())
    .thenReturn(ds.getInstanceCount() - 1);

    KubernetesDeployment availableK8sDeployment = Mockito.mock(KubernetesDeployment.class);
    when(availableK8sDeployment.getAvailableReplicaCount())
    .thenReturn(ds.getInstanceCount());

    when(this.k8sDeploymentApi
            .getDeploymentById(
                    ds.getExternalId(),
                    ds.getNamespace(),
                    K8sUtil.getK8sName(ds))).thenAnswer(new Answer<KubernetesDeployment>() {
                        private int i = 0;

                        @Override
                        public KubernetesDeployment answer(InvocationOnMock invocation) {
                            if (this.i++ == count) {
                                return availableK8sDeployment;
                            } else {
                                return unavailableK8sDeployment;
                            }
                        }
                    });
}

@Test
public void testNotifiesNewCallbackOfResourceIfCallbackIsAddedDuringOnResourceReady() {
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback existingCallback = mock(ResourceCallback.class);
  final ResourceCallback newCallback = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.addCallback(newCallback);
      return null;
    }
  }).when(existingCallback).onResourceReady(anyResource(), isADataSource());

  job.addCallback(existingCallback);
  job.start(harness.decodeJob);
  job.onResourceReady(harness.resource, harness.dataSource);

  verify(newCallback).onResourceReady(eq(harness.engineResource), eq(harness.dataSource));
}

@Test
public void testRemovingCallbackDuringOnExceptionIsIgnoredIfCallbackHasAlreadyBeenCalled() {
  harness = new EngineJobHarness();
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback cb = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.removeCallback(cb);
      return null;
    }
  }).when(cb).onLoadFailed(any(GlideException.class));

  GlideException exception = new GlideException("test");
  job.addCallback(cb);
  job.start(harness.decodeJob);
  job.onLoadFailed(exception);

  verify(cb, times(1)).onLoadFailed(eq(exception));
}

@Test
public void
testRemovingCallbackDuringOnResourceReadyPreventsResourceFromBeingAcquiredForCallback() {
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback notYetCalled = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.removeCallback(notYetCalled);
      return null;
    }
  }).when(harness.cb).onResourceReady(anyResource(), isADataSource());

  job.addCallback(notYetCalled);
  job.start(harness.decodeJob);

  job.onResourceReady(harness.resource, harness.dataSource);

  // Once for notifying, once for called.
  verify(harness.engineResource, times(2)).acquire();
}

@Before
public void before() throws Exception {
    Answer<Cancelable> runAndReturn = new Answer<Cancelable>() {
        @Override
        public Cancelable answer(InvocationOnMock invocation) throws Exception {
            try {
                Function0<Unit> block = invocation.getArgument(0);
                block.invoke();
            } catch (Exception e) {
                e.printStackTrace();
                Assert.fail(e.getMessage());
            }
            return canceler;
        }
    };
    doAnswer(runAndReturn).when(mockRunner).runWithCancel(ArgumentMatchers.<Function0<Unit>>any());
    doAnswer(runAndReturn).when(mockRunner).run(ArgumentMatchers.<Function0<Unit>>any());
}

@Test
public void testAddAnswerToQuestion_notFirstAnswer_shouldNotMarkItAsCorrect() {
    when(answerService.countAnswersInQuestion(question)).thenReturn(1);
    question.setIsValid(true);
    question.setCorrectAnswer(null);
    Answer answer = new Answer();
    answer.setId(1l);

    when(answerService.save(any(Answer.class))).thenAnswer(new org.mockito.stubbing.Answer<Answer>() {
        @Override
        public Answer answer(InvocationOnMock invocation) throws Throwable {
            Object[] args = invocation.getArguments();
            return (Answer) args[0];
        }
    });

    service.addAnswerToQuestion(answer, question);

    assertTrue(question.getIsValid());
    verify(answerService, times(1)).save(answer);
    verify(questionRepository, never()).save(question);
}

@Test public void appStartAfterProcessDeathAndViewStateRecreationFromBundle() {
  ActivityMvpViewStateDelegateImpl<MvpView, MvpPresenter<MvpView>, ViewState<MvpView>> delegate =
      new ActivityMvpViewStateDelegateImpl<>(activity, callback, true);

  Mockito.doAnswer(new Answer() {
    @Override public Object answer(InvocationOnMock invocation) throws Throwable {
      viewState = Mockito.spy(new SimpleRestorableViewState());
      return viewState;
    }
  }).when(callback).createViewState();

  Bundle bundle = BundleMocker.create();
  bundle.putString(ActivityMvpViewStateDelegateImpl.KEY_MOSBY_VIEW_ID, "123456789");

  startActivity(delegate, bundle, 1, 1, 1, 1, 1, 1, false, 1, 0, 1);
}

@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
  boolean interrupted = false;
  try {
    Thread.sleep(r.nextInt(maxSleepTime));
  } catch (InterruptedException ie) {
    interrupted = true;
  }
  try {
    return invocation.callRealMethod();
  } finally {
    if (interrupted) {
      Thread.currentThread().interrupt();
    }
  }
}

@Before
public void setup() throws Exception {
    ledger = new Ledger();

    backlog = new Backlog();

    Storage mockStorage = mock(Storage.class);
    when(mockStorage.getBacklog()).thenReturn(backlog);
    service = Mockito.spy(new AccountService(mockStorage));
    doAnswer(new Answer<IAccount>() {
        @Override
        public IAccount answer(InvocationOnMock invocation) throws Throwable {
            long id = Format.ID.accountId(invocation.getArgument(0));
            return ledger.getAccount(id);
        }
    }).when(service).getAccount(anyString());

    Ed25519SignatureVerifier signatureVerifier = new Ed25519SignatureVerifier();
    CryptoProvider cryptoProvider = new CryptoProvider(new SignedObjectMapper(0L));
    cryptoProvider.addProvider(signatureVerifier);
    cryptoProvider.setDefaultProvider(signatureVerifier.getName());
    CryptoProvider.init(cryptoProvider);
}

private Operation<Void, UpdateDatabaseDdlMetadata> mockOperation(boolean error)
{
    @SuppressWarnings("unchecked")
    Operation<Void, UpdateDatabaseDdlMetadata> op = mock(Operation.class);
    when(op.getName()).then(new Returns("TEST_OPERATION"));
    when(op.isDone()).then(new Answer<Boolean>()
    {
        @Override
        public Boolean answer(InvocationOnMock invocation) throws Throwable
        {
            return reportDone;
        }
    });
    when(op.reload()).then(new Returns(op));
    if (error)
        when(op.getResult()).thenThrow(
                SpannerExceptionFactory.newSpannerException(ErrorCode.INVALID_ARGUMENT, "Some exception"));
    else
        when(op.getResult()).then(new Returns(null));
    UpdateDatabaseDdlMetadata metadata = UpdateDatabaseDdlMetadata.getDefaultInstance();
    when(op.getMetadata()).then(new Returns(metadata));

    return op;
}

@Before
public void setUp() throws Exception
{
    moduleService = new ModuleServiceImpl();
    Resource simpleMod = new PathMatchingResourcePatternResolver().getResource("classpath:alfresco/module/simplemodule.properties");
    assertNotNull(simpleMod);
    RegistryService reg = mock(RegistryService.class);
    ApplicationContext applicationContext = mock(ApplicationContext.class);

    when(reg.getProperty((RegistryKey) anyObject())).thenAnswer(new Answer<Serializable>()
    {
        public Serializable answer(InvocationOnMock invocation) throws Throwable
        {
            RegistryKey key = (RegistryKey) invocation.getArguments()[0];
            return new ModuleVersionNumber("1.1");
        }
    });
    doReturn(Arrays.asList("fee", "alfresco-simple-module", "fo")).when(reg).getChildElements((RegistryKey) anyObject());
    doReturn(new Resource[] {simpleMod}).when(applicationContext).getResources(anyString());
    moduleService.setRegistryService(reg);
    moduleService.setApplicationContext(applicationContext);
}

/**
 * Test that appender buffers events for 3 seconds before sending.
 *
 * @throws IOException Signals that an I/O exception has occurred.
 * @throws InterruptedException the interrupted exception
 * @throws ExecutionException the execution exception
 */
@Test
public void test3sWait() throws IOException, InterruptedException, ExecutionException {
    BulkSender sender = Mockito.mock(BulkSender.class);
    ElasticSearchRestAppender appender = ElasticSearchRestAppender.newBuilder()
        .withName("test-3s-wait")
        .withBulkSender(sender)
        .withMaxBulkSize(0)
        .withMaxDelayTime(3000L)
        .build();
    verify(sender, times(0)).send(anyString());
    appender.append(getLogEvent());
    verify(sender, times(0)).send(anyString());
    CompletableFuture<Long> future = new CompletableFuture<>();
    long start = System.nanoTime();
    doAnswer(new Answer<Void>() {
        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            long elapsed = System.nanoTime() - start;
            future.complete(elapsed); 
            return null;
        }
    }).when(sender).send(anyString());
    assertTrue(future.get() >= 3000000);
    verify(sender, times(1)).send(anyString());
}

@Test
public void testGetScaleMatrix() throws Exception {
    Bitmap3DString o = new Bitmap3DString(font, string);

    PowerMockito.doAnswer(new Answer<Object>() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
            Object[] args = invocation.getArguments();
            float[] matrix = (float[])args[0];
            for(int counter = 0; counter < matrix.length; counter++) {
                matrix[counter] = 2.0f;
            }
            return null;
        }
    }).when(Matrix.class, "scaleM", o.scaleMatrix, 0, o.getScaleX(), o.getScaleY(), o.getScaleZ());

    float[] expected = { 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f, 2.0f };
    assertArrayEquals(expected, o.getScaleMatrix(), 0);
}

@Before
public void setUp() throws Exception {
    loggerMock = mock(Log4jLogger.class);

    requestMock = mock(HttpServletRequest.class);
    map = new HashMap<String, String[]>();

    when(requestMock.getParameterMap()).thenReturn(map);
    when(requestMock.getRemoteAddr()).thenReturn(REMOTE_HOST);

    doAnswer(new Answer<String[]>() {
        @Override
        public String[] answer(InvocationOnMock invocation)
                throws Throwable {
            return map.get(invocation.getArguments()[0]);
        }
    }).when(requestMock).getParameterValues(anyString());

    when(requestMock.getQueryString()).thenReturn(queryString);

    RequestWithCleanParameters.logger = loggerMock;
}

private static void setupUploadS3Mock(UploadService mockUploadService) {
  MediaType mediaType = MediaType.parse("text/xml");
  ResponseBody responseBody = ResponseBody.create(mediaType, "");
  final Response<ResponseBody> response = Response.success(responseBody,
      Headers.of("ETag", "test-etag"));
  Mockito
      .doAnswer(new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
          return Calls.response(response);
        }
      })
      .when(mockUploadService)
      .uploadS3(Mockito.<String, String>anyMap(), Mockito.anyString(),
          Mockito.any(RequestBody.class));
}

@Test(expected = OperationNotPermittedException.class)
public void revokeUsersFromGroup_userNotBelongToOrg() throws Exception {
    // given
    group.setIsDefault(false);
    group.setOrganization(org);
    doReturn(platformUser).when(userGroupService.getDm()).find(
            any(PlatformUser.class));
    when(userGroupService.getDm().find(any(DomainObject.class)))
            .thenAnswer(new Answer<DomainObject<?>>() {

                @Override
                public DomainObject<?> answer(InvocationOnMock invocation) {
                    Object template = invocation.getArguments()[0];
                    if (template instanceof UserGroup) {
                        return group;
                    } else if (template instanceof PlatformUser) {
                        return platformUser;
                    }
                    return null;
                }
            });

    // when
    userGroupService.revokeUsersFromGroup(group,
            Collections.singletonList(user));
}

@Before
@SuppressWarnings("unchecked")
public void createRestClient() throws IOException {
    CloseableHttpAsyncClient httpClient = mock(CloseableHttpAsyncClient.class);
    when(httpClient.<HttpResponse>execute(any(HttpAsyncRequestProducer.class), any(HttpAsyncResponseConsumer.class),
           any(HttpClientContext.class), any(FutureCallback.class))).thenAnswer(new Answer<Future<HttpResponse>>() {
        @Override
        public Future<HttpResponse> answer(InvocationOnMock invocationOnMock) throws Throwable {
            HttpAsyncRequestProducer requestProducer = (HttpAsyncRequestProducer) invocationOnMock.getArguments()[0];
            HttpUriRequest request = (HttpUriRequest)requestProducer.generateRequest();
            HttpHost httpHost = requestProducer.getTarget();
            HttpClientContext context = (HttpClientContext) invocationOnMock.getArguments()[2];
            assertThat(context.getAuthCache().get(httpHost), instanceOf(BasicScheme.class));
            FutureCallback<HttpResponse> futureCallback = (FutureCallback<HttpResponse>) invocationOnMock.getArguments()[3];
            //return the desired status code or exception depending on the path
            if (request.getURI().getPath().equals("/soe")) {
                futureCallback.failed(new SocketTimeoutException(httpHost.toString()));
            } else if (request.getURI().getPath().equals("/coe")) {
                futureCallback.failed(new ConnectTimeoutException(httpHost.toString()));
            } else if (request.getURI().getPath().equals("/ioe")) {
                futureCallback.failed(new IOException(httpHost.toString()));
            } else {
                int statusCode = Integer.parseInt(request.getURI().getPath().substring(1));
                StatusLine statusLine = new BasicStatusLine(new ProtocolVersion("http", 1, 1), statusCode, "");
                futureCallback.completed(new BasicHttpResponse(statusLine));
            }
            return null;
        }
    });
    int numHosts = RandomNumbers.randomIntBetween(getRandom(), 2, 5);
    httpHosts = new HttpHost[numHosts];
    for (int i = 0; i < numHosts; i++) {
        httpHosts[i] = new HttpHost("localhost", 9200 + i);
    }
    failureListener = new HostsTrackingFailureListener();
    restClient = new RestClient(httpClient, 10000, new Header[0], httpHosts, null, failureListener);
}

@Test
public void testHandlesNonEngineResourcesFromCacheIfPresent() {
  final Object expected = new Object();
  @SuppressWarnings("rawtypes") Resource fromCache = mockResource();
  when(fromCache.get()).thenReturn(expected);
  when(harness.cache.remove(eq(harness.cacheKey))).thenReturn(fromCache);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      Resource<?> resource = (Resource<?>) invocationOnMock.getArguments()[0];
      assertEquals(expected, resource.get());
      return null;
    }
  }).when(harness.cb).onResourceReady(anyResource(), isADataSource());

  harness.doLoad();

  verify(harness.cb).onResourceReady(anyResource(), isADataSource());
}

@Test
public void load_afterResourceIsGcedFromActive_returnsFromMemoryCache() {
  when(harness.resource.getResource()).thenReturn(mock(Resource.class));
  when(harness.resource.isCacheable()).thenReturn(true);
  harness.cache = new LruResourceCache(100);
  doAnswer(new Answer<Object>() {
    @Override
    public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
      harness.getEngine().onEngineJobComplete(harness.cacheKey, harness.resource);
      return null;
    }
  }).when(harness.job).start(any(DecodeJob.class));
  harness.doLoad();
  ArgumentCaptor<IdleHandler> captor = ArgumentCaptor.forClass(IdleHandler.class);
  verify(GlideShadowLooper.queue).addIdleHandler(captor.capture());
  captor.getValue().queueIdle();
  harness.doLoad();
  verify(harness.cb).onResourceReady(any(Resource.class), eq(DataSource.MEMORY_CACHE));
}

@Test
public void shouldBulkLoadManyFamilyHLog() throws IOException {
  when(log.append(any(HTableDescriptor.class), any(HRegionInfo.class),
          any(WALKey.class), argThat(bulkLogWalEditType(WALEdit.BULK_LOAD)),
          any(boolean.class))).thenAnswer(new Answer() {
            public Object answer(InvocationOnMock invocation) {
              WALKey walKey = invocation.getArgumentAt(2, WALKey.class);
              MultiVersionConcurrencyControl mvcc = walKey.getMvcc();
              if (mvcc != null) {
                MultiVersionConcurrencyControl.WriteEntry we = mvcc.begin();
                walKey.setWriteEntry(we);
              }
              return 01L;
            };
          });
  testRegionWithFamilies(family1, family2).bulkLoadHFiles(withFamilyPathsFor(family1, family2),
          false, null);
  verify(log).sync(anyLong());
}

@Test
public void testRemovingCallbackDuringOnResourceReadyIsIgnoredIfCallbackHasAlreadyBeenCalled() {
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback cb = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.removeCallback(cb);
      return null;
    }
  }).when(cb).onResourceReady(anyResource(), isADataSource());

  job.addCallback(cb);
  job.start(harness.decodeJob);
  job.onResourceReady(harness.resource, harness.dataSource);

  verify(cb, times(1)).onResourceReady(anyResource(), isADataSource());
}

@Override
public DatagramSocket answer(InvocationOnMock invocation) throws Throwable {
    //if needed, the Socket can be retrieved with:
    //DatagramSocket socket = (DatagramSocket) invocation.getMock();
    int timeout = 5000;
    Object[] args = invocation.getArguments();
    if (mCount < mResponseToSend) {
        Thread.sleep(timeout/2);
        ((DatagramPacket) args[0]).setData(mAnswers[mCount].getBytes());
        mCount++;
        return null;
    } else {
        Thread.sleep(timeout);
        throw new InterruptedIOException();
    }
}

@Test
public void testRemovingCallbackDuringOnExceptionPreventsCallbackFromBeingCalledIfNotYetCalled() {
  harness = new EngineJobHarness();
  final EngineJob<Object> job = harness.getJob();
  final ResourceCallback called = mock(ResourceCallback.class);
  final ResourceCallback notYetCalled = mock(ResourceCallback.class);

  doAnswer(new Answer<Void>() {
    @Override
    public Void answer(InvocationOnMock invocationOnMock) throws Throwable {
      job.removeCallback(notYetCalled);
      return null;
    }
  }).when(called).onLoadFailed(any(GlideException.class));

  job.addCallback(called);
  job.addCallback(notYetCalled);
  job.start(harness.decodeJob);
  job.onLoadFailed(new GlideException("test"));

  verify(notYetCalled, never()).onResourceReady(anyResource(), isADataSource());
}

@Test
public void bucketWrapperShouldInvokeOnFailureWhenCreateBucketFails() {
  doAnswer(new Answer<Object>() {
    public Object answer(InvocationOnMock invocation) {
      // 3rd argument is Completion object sent to BucketOperatorImpl.createRedundantBucket
      ((Completion) invocation.getArguments()[3]).onFailure();
      return null;
    }
  }).when(delegate).createRedundantBucket(eq(targetMember), eq(bucketId),
      eq(colocatedRegionBytes), any(Completion.class));

  Completion completionSentToWrapper = mock(Completion.class);
  wrapper.createRedundantBucket(targetMember, bucketId, colocatedRegionBytes,
      completionSentToWrapper);

  // verify onFailure is invoked
  verify(completionSentToWrapper, times(1)).onFailure();
}

@Test
public void testImageSfw() throws Exception {
  Mockito.doAnswer(new Answer() {
    @Override
    public Call<ResponseBody> answer(InvocationOnMock invocation) throws Throwable {
      String handle = invocation.getArgument(1);
      String json = "{'sfw': " + (handle.equals("safe") ? "true" : "false") + "}";
      MediaType mediaType = MediaType.parse("application/json");
      return Calls.response(ResponseBody.create(mediaType, json));
    }
  })
      .when(Networking.getCdnService())
      .transform(Mockito.anyString(), Mockito.anyString());

  Config config = new Config("apiKey", "policy", "signature");

  FileLink safe = new FileLink(config, "safe");
  FileLink notSafe = new FileLink(config, "notSafe");

  Assert.assertTrue(safe.imageSfw());
  Assert.assertFalse(notSafe.imageSfw());
}

private void mockTextUtils() {
    mockStatic(TextUtils.class);
    PowerMockito.when(TextUtils.isEmpty(any(CharSequence.class))).thenAnswer(new Answer<Boolean>() {
        @Override
        public Boolean answer(InvocationOnMock invocation) throws Throwable {
            CharSequence a = (CharSequence) invocation.getArguments()[0];
            return !(a != null && a.length() > 0);
        }
    });
}