Java 类org.mockito.ArgumentCaptor 实例源码

@Test
public void oldSecurityShouldFailIfNotAuthorized() throws Exception {
  when(this.securityService.isClientSecurityRequired()).thenReturn(true);
  when(this.securityService.isIntegratedSecurity()).thenReturn(false);

  doThrow(new NotAuthorizedException("")).when(this.authzRequest)
      .registerInterestAuthorize(eq(REGION_NAME), eq(KEY), anyInt(), any());

  this.registerInterest61.cmdExecute(this.message, this.serverConnection, 0);

  verify(this.authzRequest).registerInterestAuthorize(eq(REGION_NAME), eq(KEY), anyInt(), any());

  ArgumentCaptor<NotAuthorizedException> argument =
      ArgumentCaptor.forClass(NotAuthorizedException.class);
  verify(this.chunkedResponseMessage).addObjPart(argument.capture());

  assertThat(argument.getValue()).isExactlyInstanceOf(NotAuthorizedException.class);
  verify(this.chunkedResponseMessage).sendChunk(this.serverConnection);
}

@Test
public void testReleaseClosesOpenFileChannel()
        throws Exception {
    // Given
    FileHandleFiller filler = mock(FileHandleFiller.class);
    ArgumentCaptor<Integer> handleCaptor = ArgumentCaptor.forClass(Integer.class);
    doNothing().when(filler).setFileHandle(handleCaptor.capture());
    Path fooBar = mockPath(mirrorRoot, "foo.bar");
    FileChannel fileChannel = mock(FileChannel.class);
    when(fileSystem.provider().newFileChannel(eq(fooBar), eq(set(StandardOpenOption.READ)))).thenReturn(fileChannel);
    fs.open("foo.bar", filler);
    // When
    int result = fs.release("foo.bar", handleCaptor.getValue());
    // Then
    assertThat(result).isEqualTo(SUCCESS);
    verify(fileChannelCloser).close(fileChannel);
    verifyNoMoreInteractions(fileChannel);
}

@Test
public void statusShouldSendNoMatchResponseToTransaction_whenNoMatchResponseSentFromMatchingServiceCycle3Match() throws Exception {
    final String requestId = "requestId";
    final SessionId sessionId = SessionId.createNewSessionId();
    Cycle3MatchRequestSentState state = aCycle3MatchRequestSentState().withSessionId(sessionId).withRequestId(requestId).build();
    Cycle3MatchRequestSentStateController controller =
            new Cycle3MatchRequestSentStateController(state, eventSinkHubEventLogger, stateTransitionAction, policyConfiguration,
                    null, null, transactionsConfigProxy, matchingServiceConfigProxy, assertionRestrictionFactory, attributeQueryService);
    ArgumentCaptor<NoMatchState> argumentCaptor = ArgumentCaptor.forClass(NoMatchState.class);
    NoMatchFromMatchingService noMatchFromMatchingService = new NoMatchFromMatchingService(matchingServiceEntityId, requestId);

    controller.handleNoMatchResponseFromMatchingService(noMatchFromMatchingService);

    verify(stateTransitionAction, times(1)).transitionTo(argumentCaptor.capture());
    NoMatchStateController noMatchStateController = new NoMatchStateController(argumentCaptor.getValue(), responseFromHubFactory);
    ResponseProcessingDetails responseProcessingDetails = noMatchStateController.getResponseProcessingDetails();
    assertThat(responseProcessingDetails.getResponseProcessingStatus()).isEqualTo(ResponseProcessingStatus.SEND_NO_MATCH_RESPONSE_TO_TRANSACTION);
    assertThat(responseProcessingDetails.getSessionId()).isEqualTo(sessionId);
}

private void processSMimeEncryptedMessageAndCaptureMocks(
        Message message, Body encryptedBody, OutputStream outputStream)
        throws Exception {
    messageCryptoHelper.asyncStartOrResumeProcessingMessage(message, messageCryptoCallback,
            null, null, false);

    ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class);
    ArgumentCaptor<SMimeDataSource> dataSourceCaptor = ArgumentCaptor.forClass(SMimeDataSource.class);
    ArgumentCaptor<ISMimeSinkResultCallback> callbackCaptor = ArgumentCaptor.forClass(
            ISMimeSinkResultCallback.class);
    verify(sMimeApi).executeApiAsync(intentCaptor.capture(), dataSourceCaptor.capture(),
            any(SMimeDataSink.class), callbackCaptor.capture());

    capturedApiIntent = intentCaptor.getValue();
    capturedSMimeCallback = callbackCaptor.getValue();

    SMimeDataSource dataSource = dataSourceCaptor.getValue();
    dataSource.writeTo(outputStream);
    verify(encryptedBody).writeTo(outputStream);
}

@Test
public void logEventSinkHubEvent_shouldSendEvent() throws Exception {
    EventSinkHubEventLogger eventLogger = new EventSinkHubEventLogger(serviceInfo, eventSinkProxy);
    ArgumentCaptor<EventSinkHubEvent> eventCaptor = ArgumentCaptor.forClass(EventSinkHubEvent.class);
    SessionId expectedSessionId = aSessionId().build();

    eventLogger.logRequestFromHub(expectedSessionId, "transaction-entity-id");
    verify(eventSinkProxy).logHubEvent(eventCaptor.capture());

    EventSinkHubEvent actualEvent = eventCaptor.getValue();

    assertThat(actualEvent.getEventType()).isEqualTo(HUB_EVENT);
    assertThat(actualEvent.getSessionId()).isEqualTo(expectedSessionId.getSessionId());
    Map<EventDetailsKey, String> details = actualEvent.getDetails();

    assertThat(details.containsKey(hub_event_type)).isTrue();
    String hubEventType = details.get(hub_event_type);
    assertThat(hubEventType).isEqualTo(RECEIVED_AUTHN_REQUEST_FROM_HUB);
}

@Test
public void testResultWithLevelAndThrowableAndArgs() throws Exception {
    SmartLog.start(output);

    SmartLog.format(new SimpleTextFormat("${result}"));
    final RuntimeException exception = new RuntimeException("test");
    SmartLog.result(LogLevel.WARN, exception, "test-result: %d", 42);

    SmartLog.finish();

    final ArgumentCaptor<String> msgCaptor = ArgumentCaptor.forClass(String.class);
    final ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class);
    Mockito.verify(logger).warn(msgCaptor.capture(), exceptionCaptor.capture());

    Assertions.assertThat(msgCaptor.getValue())
            .matches("test-result: 42");
    assertThat(exceptionCaptor.getValue())
            .isSameAs(exception);
}

@Test
public void show_and_remove_button_several_activities() {
    final ArgumentCaptor<View> viewArgumentCaptor = ArgumentCaptor.forClass(View.class);

    final WindowManager windowManager1 = mock(WindowManager.class);
    final Activity activity1 = mockActivity(windowManager1);
    final ArgumentCaptor<View> viewArgumentCaptor1 = ArgumentCaptor.forClass(View.class);

    view.showButton(activity, false);
    verify(windowManager).addView(viewArgumentCaptor.capture(), any());

    view.showButton(activity1, false);
    verify(windowManager1).addView(viewArgumentCaptor1.capture(), any());

    view.removeButton(activity);
    verify(windowManager).removeView(viewArgumentCaptor.getValue());

    view.removeButton(activity1);
    verify(windowManager1).removeView(viewArgumentCaptor1.getValue());
}

@Test
public void testEnablePoweredNotifications() throws Exception {
    Notification<Boolean> notification = mock(Notification.class);
    ArgumentCaptor<BluetoothNotification> captor = ArgumentCaptor.forClass(BluetoothNotification.class);
    doNothing().when(bluetoothAdapter).enablePoweredNotifications(captor.capture());

    tinyBAdapter.enablePoweredNotifications(notification);

    verify(bluetoothAdapter, times(1)).enablePoweredNotifications(captor.getValue());
    verifyNoMoreInteractions(bluetoothAdapter, notification);

    captor.getValue().run(Boolean.TRUE);
    verify(notification, times(1)).notify(Boolean.TRUE);

    doThrow(RuntimeException.class).when(notification).notify(anyBoolean());
    captor.getValue().run(Boolean.FALSE);
    verify(notification, times(1)).notify(Boolean.FALSE);
}

@SuppressWarnings("unchecked")
@Test
public void testAuthenticateTMForController_noControllerSettings()
        throws Throwable {

    // given
    VOUserDetails manager = createVOUserDetails(10000, "user", "tp123");
    Mockito.doThrow(new ConfigurationException("test")).when(configService)
            .getAuthenticationForBESTechnologyManager(anyString(),
                    any(ServiceInstance.class), Matchers.anyMap());
    Mockito.doReturn(null).when(authService)
            .getAuthenticatedTMForController(anyString(),
                    any(PasswordAuthentication.class));
    ArgumentCaptor<PasswordAuthentication> ac = ArgumentCaptor
            .forClass(PasswordAuthentication.class);

    // when
    authenticateTMForController(CTRL_ID, manager.getUserId(), "pass");

    // then
    verify(authService).getAuthenticatedTMForController(
            anyString(), ac.capture());
    assertEquals(manager.getUserId(), ac.getValue().getUserName());
    assertEquals("pass", ac.getValue().getPassword());
}

@Test
public void saveOperatorRevenueShare() throws Exception {
    PORevenueShare po = new PORevenueShare();
    po.setKey(101L);
    po.setRevenueShare(BigDecimal.TEN);
    po.setVersion(2);
    ArgumentCaptor<RevenueShareModel> captor = ArgumentCaptor
            .forClass(RevenueShareModel.class);

    // when
    Response response = bean.saveOperatorRevenueShare(1L, po);

    // then
    assertTrue(response.getResults().isEmpty());
    assertTrue(response.getWarnings().isEmpty());
    assertTrue(response.getReturnCodes().isEmpty());
    verify(bean.spPartnerServiceLocal, times(1)).saveOperatorRevenueShare(
            eq(1L), captor.capture(), eq(2));
    assertEquals(BigDecimal.TEN, captor.getValue().getRevenueShare());
    assertEquals(RevenueShareModelType.OPERATOR_REVENUE_SHARE, captor
            .getValue().getRevenueShareModelType());
    assertEquals(101L, captor.getValue().getKey());
}

@SuppressWarnings({"rawtypes", "unchecked"})
@Test
public void findOne() throws Exception {

    resourceAdapter.findOne(1L, queryAdapter);

    ArgumentCaptor<Iterable> linksResources = ArgumentCaptor.forClass(Iterable.class);
    ArgumentCaptor<Iterable> metaResources = ArgumentCaptor.forClass(Iterable.class);
    ArgumentCaptor<RepositoryFilterContext> contexts = ArgumentCaptor.forClass(RepositoryFilterContext.class);

    Mockito.verify(filter, Mockito.times(1)).filterRequest(contexts.capture(), Mockito.any(RepositoryRequestFilterChain.class));
    Mockito.verify(filter, Mockito.times(1)).filterResult(Mockito.any(RepositoryFilterContext.class), Mockito.any(RepositoryResultFilterChain.class));
    Mockito.verify(filter, Mockito.times(1)).filterLinks(Mockito.any(RepositoryFilterContext.class), linksResources.capture(), Mockito.any(RepositoryLinksFilterChain.class));
    Mockito.verify(filter, Mockito.times(1)).filterMeta(Mockito.any(RepositoryFilterContext.class), metaResources.capture(), Mockito.any(RepositoryMetaFilterChain.class));

    Assert.assertEquals(1, linksResources.getAllValues().size());
    Assert.assertEquals(1, metaResources.getAllValues().size());
    Assert.assertEquals(1, contexts.getAllValues().size());
    RepositoryFilterContext context = contexts.getAllValues().iterator().next();
    RepositoryRequestSpec requestSpec = context.getRequest();
    Assert.assertEquals(queryAdapter, requestSpec.getQueryAdapter());
    Assert.assertEquals(1L, requestSpec.getId());
    Assert.assertEquals(Collections.singleton(1L), requestSpec.getIds());
    Assert.assertSame(querySpec, requestSpec.getQuerySpec(userInfo));
}

@SuppressWarnings({ "rawtypes", "unchecked" })
@Test
public void testDataChangeListener() throws Exception {
    DataChangeListener listener = mock(DataChangeListener.class);
    InstanceIdentifier<ListItem> wildCard = InstanceIdentifier.builder(ListenerTest.class)
            .child(ListItem.class).build();
    ListenerRegistration<DataChangeListener> reg = getDataBroker().registerDataChangeListener(
            LogicalDatastoreType.OPERATIONAL, wildCard, listener, AsyncDataBroker.DataChangeScope.SUBTREE);

    final ListItem item = writeListItem();

    ArgumentCaptor<AsyncDataChangeEvent> captor = ArgumentCaptor.forClass(AsyncDataChangeEvent.class);

    verify(listener, timeout(100)).onDataChanged(captor.capture());

    AsyncDataChangeEvent event = captor.getValue();
    assertEquals("createdData", 1, event.getCreatedData().size());
    assertEquals("ListItem", item, event.getCreatedData().values().iterator().next());
}

@Test
public void monitorFailuresForSpecificMetastore() throws Throwable {
  CurrentMonitoredMetaStoreHolder.monitorMetastore("metastoreName");
  when(pjp.proceed()).thenThrow(new ClassCastException());
  try {
    aspect.monitor(pjp, monitored);
  } catch (ClassCastException e) {
    // Expected
  }

  ArgumentCaptor<String> metricCaptor = ArgumentCaptor.forClass(String.class);
  verify(counterService, times(2)).increment(metricCaptor.capture());
  assertThat(metricCaptor.getAllValues().get(0), is("counter.Type_Anonymous.myMethod.metastoreName.calls"));
  assertThat(metricCaptor.getAllValues().get(1), is("counter.Type_Anonymous.myMethod.metastoreName.failure"));

  metricCaptor = ArgumentCaptor.forClass(String.class);
  ArgumentCaptor<Long> durationCaptor = ArgumentCaptor.forClass(Long.class);
  verify(gaugeService).submit(metricCaptor.capture(), durationCaptor.capture());
  assertThat(metricCaptor.getValue(), is("timer.Type_Anonymous.myMethod.metastoreName.duration"));
}

@Test
public void itCanAuthenticateWithAuthLogin() throws Exception {
  String username = "user";
  String password = "password";

  // do the initial request, which just includes the username
  session.authLogin("user", "password");

  verify(channel).writeAndFlush(new DefaultSmtpRequest("AUTH", "LOGIN", encodeBase64(username)));

  // now the second request, which sends the password
  responseFuture.complete(Lists.newArrayList(INTERMEDIATE_RESPONSE));

  // this is sent to the second invocation of writeAndFlush
  ArgumentCaptor<Object> bufCaptor = ArgumentCaptor.forClass(Object.class);
  verify(channel, times(2)).writeAndFlush(bufCaptor.capture());
  ByteBuf capturedBuffer = (ByteBuf) bufCaptor.getAllValues().get(1);

  String actualString = capturedBuffer.toString(0, capturedBuffer.readableBytes(), StandardCharsets.UTF_8);
  assertThat(actualString).isEqualTo(encodeBase64(password) + "\r\n");
}

@Test
public void testLogArray() throws Exception {

    final TiLog.Logger logger = mock(TiLog.Logger.class);
    final LoggingInterceptor loggingInterceptor = new LoggingInterceptor(logger);
    final TestView view = loggingInterceptor.intercept(new TestViewImpl());

    final ArgumentCaptor<String> msgCaptor = ArgumentCaptor.forClass(String.class);

    final String[] array = new String[]{"Buenos Aires", "Córdoba", "La Plata"};
    view.twoArgs(array, "B");
    verify(logger).log(anyInt(), anyString(), msgCaptor.capture());

    assertThat(msgCaptor.getValue())
            .matches("twoArgs\\(\\{String\\[\\]\\[3\\]@[\\da-f]{1,8}\\} \\"
                    + "[Buenos Aires, Córdoba, La Plata\\], B\\)");
}

@Test
public void testLogEmptyList() throws Exception {

    final TiLog.Logger logger = mock(TiLog.Logger.class);
    final LoggingInterceptor loggingInterceptor = new LoggingInterceptor(logger);
    final TestView view = loggingInterceptor.intercept(new TestViewImpl());

    final ArgumentCaptor<String> msgCaptor = ArgumentCaptor.forClass(String.class);

    view.twoArgs(new ArrayList(), "B");
    verify(logger).log(anyInt(), anyString(), msgCaptor.capture());

    assertThat(msgCaptor.getValue())
            .matches("twoArgs\\("
                    + "\\{ArrayList\\[0\\]@[\\da-f]{1,8}\\} \\[\\], "
                    + "B"
                    + "\\)");
}

StateBuilder getFruitSuccess(final FruitPojo fruitPojo) {

        List<FruitPojo> fruitList = new ArrayList<>();
        fruitList.add(fruitPojo);

        final ArgumentCaptor<SuccessCallbackWithPayload> callback = ArgumentCaptor.forClass(SuccessCallbackWithPayload.class);

        doAnswer(__ -> {
            callback.getValue().success(fruitList);
            return null;
        })

                .when(mockCallProcessor)
                .processCall(any(), any(), any(), callback.capture(), any());

        return this;
    }

@Test
public void save() throws Exception {
    doReturn(user.getUserId()).when(ctrl).getSelectedUserId();
    doReturn(Boolean.FALSE).when(ctrl).isCurrentUserRolesChanged();
    ctrl.init(uas);
    updateData(model);

    String outcome = ctrl.save();

    assertEquals(BaseBean.OUTCOME_SUCCESS, outcome);
    verify(ctrl.getUi()).handle(response, BaseBean.INFO_USER_SAVED,
            model.getUserId().getValue());
    ArgumentCaptor<POUserAndSubscriptions> ac = ArgumentCaptor
            .forClass(POUserAndSubscriptions.class);
    verify(us).saveUserAndSubscriptionAssignment(ac.capture(),
            anyListOf(POUserGroup.class));
    verifyDataUpdate(ac.getValue());
}

@Test
public void sendMailToCreatedUser_ManagerRole_SAML_SP() throws Exception {
    // given a SAML_SP authentication mode and a user with manager role
    doReturn(Boolean.TRUE).when(cs).isServiceProvider();

    addRole(pUser, UserRoleType.SERVICE_MANAGER);

    // when sending a mail to the created user
    idSrv.sendMailToCreatedUser("secret", true, new Marketplace(), pUser);

    // then verify that mail parameters are correct
    verify(idSrv.cm, times(1)).getBaseUrlWithTenant(anyString());
    verify(idSrv.cm, times(0)).getMarketplaceUrl(anyString());

    ArgumentCaptor<Object[]> ac = ArgumentCaptor.forClass(Object[].class);
    verify(cm, times(1)).sendMail(eq(pUser),
            eq(EmailType.USER_CREATED_SAML_SP), ac.capture(),
            any(Marketplace.class));
    Object[] value = ac.getValue();
    assertEquals(pUser.getUserId(), value[0]);
}

@Test
public void updateMarketplace_OrgNotChanged() throws Exception {
    ArgumentCaptor<VOMarketplace> captor = ArgumentCaptor
            .forClass(VOMarketplace.class);

    Marketplace model = umpb.getModel();
    String mId = "marketplaceId";
    model.setMarketplaceId(mId);
    model.setOwningOrganizationId("owningOrganizationId");
    model.setOriginalOrgId(model.getOwningOrganizationId());

    umpb.updateMarketplace();

    verify(mmps, times(1)).updateMarketplace(captor.capture(),
            any(POMarketplacePriceModel.class),
            any(POPartnerPriceModel.class));
    VOMarketplace value = captor.getValue();
    verifyValueObject(model, value);

    verify(umpb, times(1)).addMessage(anyString(),
            eq(FacesMessage.SEVERITY_INFO),
            eq(BaseBean.INFO_MARKETPLACE_SAVED), eq(new Object[] { mId }));
}

/**
 * When any {@link RuntimeException} occurs, the connection should be closed, the developer should be notified on
 * this error and the admin should be warned.
 * 
 * @throws Exception
 *             Not expected to leave the method.
 */
@Test
public void whenARuntimeExceptionOccurredTheConnectionShouldBeClosedAndTheDeveloperBeWarned() throws Exception {
    final RuntimeException exampleRuntimeException = new RuntimeException(
            "The answer to everything could not be found.");
    cut.handleException(exampleRuntimeException);

    final ArgumentCaptor<Throwable> cause = ArgumentCaptor.forClass(Throwable.class);

    final ArgumentCaptor<String> developerMessage = ArgumentCaptor.forClass(String.class);
    verify(developer).unrecoverableProgrammingError(developerMessage.capture(), cause.capture());
    assertThat(developerMessage.getValue()).contains("runtime").contains("exception").contains("unhandled");
    assertThat(cause.getValue()).isSameAs(exampleRuntimeException);

    final ArgumentCaptor<String> adminMessage = ArgumentCaptor.forClass(String.class);
    verify(admin).unexpectedEvent(adminMessage.capture());
    assertThat(adminMessage.getValue()).contains("internal").contains("server").contains("client")
            .contains("connection").containsIgnoringCase("closing");

    verify(client).close();
}

@Test
public void shouldPassMakeRequest_toMessaging() throws ExecutionException, InterruptedException {
    final CoapPacket req = newCoapPacket().get().uriPath("/test").build();
    final ArgumentCaptor<Callback> callback = ArgumentCaptor.forClass(Callback.class);

    //when
    final CompletableFuture<CoapPacket> resp = server.makeRequest(req);

    //then
    verify(msg).makeRequest(eq(req), callback.capture(), eq(TransportContext.NULL));
    assertFalse(resp.isDone());

    //verify callback
    callback.getValue().call(newCoapPacket().ack(Code.C400_BAD_REQUEST).build());
    assertTrue(resp.isDone());
    assertEquals(Code.C400_BAD_REQUEST, resp.get().getCode());
}

@Test
public void addMarketplaceToOrganization()
        throws NonUniqueBusinessKeyException {
    // given
    Marketplace mp = givenMarketplace();
    mp.setKey(123L);
    Organization org = new Organization();
    org.setKey(567L);
    ArgumentCaptor<MarketplaceToOrganization> mto = ArgumentCaptor
            .forClass(MarketplaceToOrganization.class);

    // when
    service.addMarketplaceToOrganization(mp, org);

    // then
    verify(service.ds, times(1)).persist(mto.capture());
    assertEquals(mp.getKey(), mto.getValue().getMarketplace().getKey());
    assertEquals(org.getKey(), mto.getValue().getOrganization().getKey());
}

@Test
public void shouldNotifyWhenActionIsExeecuted() throws Exception {
    // GIVEN
    String path = "/actionResource/1/someAction";
    String requestType = "GET";

    ControllerRegistry controllerRegistry = new ControllerRegistry(null);
    QuerySpecAdapterBuilder queryAdapterBuilder =
            new QuerySpecAdapterBuilder(new DefaultQuerySpecDeserializer(), moduleRegistry);
    RequestDispatcher sut = new HttpRequestProcessorImpl(moduleRegistry, controllerRegistry, null, queryAdapterBuilder);

    // WHEN
    Map<String, Set<String>> parameters = new HashMap<>();
    sut.dispatchAction(path, "GET", parameters);

    // THEN

    ArgumentCaptor<DocumentFilterContext> filterContextCaptor = ArgumentCaptor.forClass(DocumentFilterContext.class);

    Mockito.verify(documentFilter, Mockito.times(1)).filter(filterContextCaptor.capture(), Mockito.any
            (DocumentFilterChain.class));
    DocumentFilterContext filterContext = filterContextCaptor.getValue();
    Assert.assertEquals("GET", filterContext.getMethod());
    Assert.assertTrue(filterContext.getJsonPath() instanceof ActionPath);
}

@Test
public void testOpenFileHandleIsUnique()
        throws Exception {
    // Given
    FileHandleFiller filler = mock(FileHandleFiller.class);
    ArgumentCaptor<Integer> handleCaptor = ArgumentCaptor.forClass(Integer.class);
    doNothing().when(filler).setFileHandle(handleCaptor.capture());
    Path fooBar = mockPath("foo.bar");
    when(fileSystem.provider().newFileChannel(eq(fooBar), eq(set(StandardOpenOption.READ)))).thenReturn(mock(FileChannel.class));
    // When
    int result = fs.open("foo.bar", filler);
    result += fs.open("foo.bar", filler);
    result += fs.open("foo.bar", filler);
    // Then
    assertThat(result).isEqualTo(SUCCESS);
    verify(filler, times(3)).setFileHandle(gt(0));
    verifyNoMoreInteractions(filler);
    verify(fileSystem.provider(), times(3)).newFileChannel(eq(fooBar), eq(set(StandardOpenOption.READ)));
    verifyNoMoreInteractions(fileSystem.provider());
    assertThat(handleCaptor.getAllValues()).hasSize(3).doesNotHaveDuplicates();
}

@Test
public void testDelivery() throws IOException {
  SignalServiceMessageSender textSecureMessageSender = mock(SignalServiceMessageSender.class);
  long                    timestamp               = System.currentTimeMillis();

  DeliveryReceiptJob deliveryReceiptJob = new DeliveryReceiptJob(context,
                                                                 "+14152222222",
                                                                 timestamp, "foo");

  ObjectGraph objectGraph = ObjectGraph.create(new TestModule(textSecureMessageSender));
  objectGraph.inject(deliveryReceiptJob);

  deliveryReceiptJob.onRun();

  ArgumentCaptor<SignalServiceAddress> captor = ArgumentCaptor.forClass(SignalServiceAddress.class);
  verify(textSecureMessageSender).sendDeliveryReceipt(captor.capture(), eq(timestamp));

  assertTrue(captor.getValue().getRelay().get().equals("foo"));
  assertTrue(captor.getValue().getNumber().equals("+14152222222"));
}

@Test
public void testAppLogout_requestManagerCalledWithCorrectRequestModel() {
    Map<String, Object> payload = createBasePayload();
    RequestModel expected = new RequestModel.Builder()
            .url(ENDPOINT_LOGOUT)
            .payload(payload)
            .headers(defaultHeaders)
            .build();

    ArgumentCaptor<RequestModel> captor = ArgumentCaptor.forClass(RequestModel.class);

    mobileEngage.appLogout();

    verify(manager).setDefaultHeaders(defaultHeaders);
    verify(manager).submit(captor.capture());

    RequestModel result = captor.getValue();
    assertRequestModels(expected, result);
}

@SuppressWarnings("unchecked")
@Test
public void testCreateBucket() throws Exception {
    ArgumentCaptor<Callable<List<String>>> argumentCaptor = ArgumentCaptor.forClass(Callable.class);
    when(executorService.schedule(argumentCaptor.capture(), anyLong(), any())).then(invocation -> {
        Callable<List<String>> callable = invocation.getArgument(0);
        callable.call();
        return null;
    });
    when(minioClient.bucketExists(eq("test1"))).thenReturn(true);
    when(minioClient.bucketExists(eq("test2"))).thenReturn(false);
    s3ClientConfig.createBuckets(minioClient, executorService, s3ClientProperties);
    verify(minioClient, times(2)).bucketExists(anyString());
    verify(minioClient).makeBucket(eq("test2"));
    verify(executorService).schedule(argumentCaptor.capture(), anyLong(), any());
    when(minioClient.bucketExists(anyString())).thenThrow(Exception.class);
    s3ClientConfig.createBuckets(minioClient, executorService, s3ClientProperties);
}

@SuppressWarnings("unchecked")
@Test
public void shouldAddLinks() throws Exception {
    io.qameta.allure.model.Link first = randomLink();
    io.qameta.allure.model.Link second = randomLink();
    io.qameta.allure.model.Link third = randomLink();

    Allure.addLinks(first, second);

    ArgumentCaptor<Consumer> captor = ArgumentCaptor.forClass(Consumer.class);
    verify(lifecycle, times(1)).updateTestCase(captor.capture());

    Consumer consumer = captor.getValue();
    TestResult result = new TestResult().withLinks(third);
    consumer.accept(result);

    assertThat(result)
            .isNotNull()
            .extracting(TestResult::getLinks)
            .containsExactly(Arrays.asList(third, first, second));
}

@Test
public void testEnableConnectedNotifications() throws Exception {
    Notification<Boolean> notification = mock(Notification.class);
    ArgumentCaptor<BluetoothNotification> captor = ArgumentCaptor.forClass(BluetoothNotification.class);
    doNothing().when(bluetoothDevice).enableConnectedNotifications(captor.capture());

    tinyBDevice.enableConnectedNotifications(notification);

    verify(bluetoothDevice, times(1)).enableConnectedNotifications(captor.getValue());
    verifyNoMoreInteractions(bluetoothDevice, notification);

    captor.getValue().run(CONNECTED);
    verify(notification, times(1)).notify(CONNECTED);

    doThrow(RuntimeException.class).when(notification).notify(anyBoolean());
    captor.getValue().run(false);
    verify(notification, times(1)).notify(false);
}

public void testPrimaryWaitForRefresh() throws Exception {
    TestRequest request = new TestRequest();
    request.setRefreshPolicy(RefreshPolicy.WAIT_UNTIL);

    TestAction testAction = new TestAction();
    TransportWriteAction.WritePrimaryResult<TestRequest, TestResponse> result =
            testAction.shardOperationOnPrimary(request, indexShard);
    CapturingActionListener<TestResponse> listener = new CapturingActionListener<>();
    result.respond(listener);
    assertNull(listener.response); // Haven't reallresponded yet

    @SuppressWarnings({ "unchecked", "rawtypes" })
    ArgumentCaptor<Consumer<Boolean>> refreshListener = ArgumentCaptor.forClass((Class) Consumer.class);
    verify(indexShard, never()).refresh(any());
    verify(indexShard).addRefreshListener(any(), refreshListener.capture());

    // Now we can fire the listener manually and we'll get a response
    boolean forcedRefresh = randomBoolean();
    refreshListener.getValue().accept(forcedRefresh);
    assertNotNull(listener.response);
    assertNull(listener.failure);
    assertEquals(forcedRefresh, listener.response.forcedRefresh);
}

@SuppressWarnings("rawtypes")
private static DOMDataTreeCandidate findCandidate(ArgumentCaptor<Collection> candidateCapture,
        YangInstanceIdentifier rootPath) {
    for (Object obj: candidateCapture.getValue()) {
        DOMDataTreeCandidate candidate = (DOMDataTreeCandidate)obj;
        if (rootPath.equals(candidate.getRootPath().getRootIdentifier())) {
            return candidate;
        }
    }

    return null;
}

@Test
public void buildCleartext__shouldSucceed() {
    cryptoStatusBuilder.setCryptoMode(CryptoMode.NO_CHOICE);
    pgpMessageBuilder.setCryptoStatus(cryptoStatusBuilder.build());

    Callback mockCallback = mock(Callback.class);
    pgpMessageBuilder.buildAsync(mockCallback);

    ArgumentCaptor<MimeMessage> captor = ArgumentCaptor.forClass(MimeMessage.class);
    verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false));
    verifyNoMoreInteractions(mockCallback);

    MimeMessage message = captor.getValue();
    assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL);
}

private CommandInterface getCommandInterface() {
    CommandInterface commandInterface = Mockito.mock(CommandInterface.class);
    argumentPacket = ArgumentCaptor.forClass(ZToolPacket.class);
    argumentListener = ArgumentCaptor.forClass(SynchronousCommandListener.class);
    argumentTimeout = ArgumentCaptor.forClass(Long.class);
    try {
        Mockito.doNothing().when(commandInterface).sendSynchronousCommand(argumentPacket.capture(),
                argumentListener.capture(), argumentTimeout.capture());
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    return commandInterface;
}

@Test
public void toResponse_shouldLogToEventSink() throws Exception {
    IdpDisabledException exception = new IdpDisabledException("my-entity");
    ArgumentCaptor<EventSinkHubEvent> captor = ArgumentCaptor.forClass(EventSinkHubEvent.class);

    exceptionMapper.toResponse(exception);

    verify(eventSinkProxy).logHubEvent(captor.capture());
    EventSinkHubEvent value = captor.getValue();
    assertThat(value.getOriginatingService()).isEqualTo(SERVICE_NAME);
    assertThat(value.getEventType()).isEqualTo(EventSinkHubEventConstants.EventTypes.ERROR_EVENT);
    assertThat(value.getSessionId()).isEqualTo(SESSION_ID.toString());
    assertThat(value.getDetails().containsKey(idp_entity_id)).as("Details should contain IDP id").isTrue();
}

/**
 * Test that if splitThreshold is zero, then we always get a separate
 * call per storage.
 */
@Test(timeout=300000)
public void testAlwaysSplit() throws IOException, InterruptedException {
  startUpCluster(0);
  NameNode nn = cluster.getNameNode();
  DataNode dn = cluster.getDataNodes().get(0);

  // Create a file with a few blocks.
  createFile(GenericTestUtils.getMethodName(), BLOCKS_IN_FILE);

  // Insert a spy object for the NN RPC.
  DatanodeProtocolClientSideTranslatorPB nnSpy =
      DataNodeTestUtils.spyOnBposToNN(dn, nn);

  // Trigger a block report so there is an interaction with the spy
  // object.
  DataNodeTestUtils.triggerBlockReport(dn);

  ArgumentCaptor<StorageBlockReport[]> captor =
      ArgumentCaptor.forClass(StorageBlockReport[].class);

  Mockito.verify(nnSpy, times(cluster.getStoragesPerDatanode())).blockReport(
      any(DatanodeRegistration.class),
      anyString(),
      captor.capture(),  Mockito.<BlockReportContext>anyObject());

  verifyCapturedArguments(captor, 1, BLOCKS_IN_FILE);
}

@Test
public void shouldAcquireOAuth2Credentials() {
    final OAuth2ConnectionFactory<?> oauth2 = mock(OAuth2ConnectionFactory.class);
    @SuppressWarnings("unchecked")
    final Applicator<AccessGrant> applicator = mock(Applicator.class);
    when(locator.providerWithId("providerId"))
        .thenReturn(new OAuth2CredentialProvider<>("providerId", oauth2, applicator));

    when(oauth2.getScope()).thenReturn("scope");
    when(oauth2.generateState()).thenReturn("state-token");
    final OAuth2Operations operations = mock(OAuth2Operations.class);
    when(oauth2.getOAuthOperations()).thenReturn(operations);
    final ArgumentCaptor<OAuth2Parameters> parameters = ArgumentCaptor.forClass(OAuth2Parameters.class);
    when(operations.buildAuthorizeUrl(parameters.capture())).thenReturn("https://provider.io/oauth/authorize");

    final AcquisitionFlow acquisition = credentials.acquire("providerId", URI.create("https://syndesis.io/api/v1/"),
        URI.create("/ui#state"));

    final CredentialFlowState expectedFlowState = new OAuth2CredentialFlowState.Builder().key("state-token")
        .providerId("providerId").redirectUrl("https://provider.io/oauth/authorize")
        .returnUrl(URI.create("/ui#state")).build();

    final AcquisitionFlow expected = new AcquisitionFlow.Builder().type(Type.OAUTH2)
        .redirectUrl("https://provider.io/oauth/authorize").state(expectedFlowState).build();
    assertThat(acquisition).isEqualTo(expected);

    final OAuth2Parameters capturedParameters = parameters.getValue();
    assertThat(capturedParameters.getRedirectUri()).isEqualTo("https://syndesis.io/api/v1/credentials/callback");
    assertThat(capturedParameters.getScope()).isEqualTo("scope");
    assertThat(capturedParameters.getState()).isEqualTo("state-token");
}

@Before public void setup() {
  MockitoAnnotations.initMocks(this);

  childEventListener = ArgumentCaptor.forClass(ChildEventListener.class);
  valueEventListener = ArgumentCaptor.forClass(ValueEventListener.class);
  transactionHandler = ArgumentCaptor.forClass(Transaction.Handler.class);
  onCompleteListener = ArgumentCaptor.forClass(OnCompleteListener.class);
}

@Test
public void testCallRepo() {
    ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
    userViewModel.getUser().observeForever(mock(Observer.class));
    userViewModel.setLogin("abc");
    verify(userRepository).loadUser(captor.capture());
    assertThat(captor.getValue(), is("abc"));
    reset(userRepository);
    userViewModel.setLogin("ddd");
    verify(userRepository).loadUser(captor.capture());
    assertThat(captor.getValue(), is("ddd"));
}

@SuppressWarnings("resource")
@Test
public void oneBooleanArgument() throws Exception {
    String sql = "SELECT status, temperature FROM root.ln.wf01.wt01 WHERE temperature < ? and time > 2017-11-1 0:13:00";
    TsfilePrepareStatement ps = new TsfilePrepareStatement(connection, client, sessHandle, sql);
    ps.setBoolean(1, false);
    ps.execute();
    ArgumentCaptor<TSExecuteStatementReq> argument = ArgumentCaptor.forClass(TSExecuteStatementReq.class);
    verify(client).executeStatement(argument.capture());
    assertEquals("SELECT status, temperature FROM root.ln.wf01.wt01 WHERE temperature < false and time > 2017-11-1 0:13:00", argument.getValue().getStatement());
}