Java 类org.mockito.Mockito 实例源码

@Test
public void validMinimumGasPrice() {
    Transaction tx1 = Mockito.mock(Transaction.class);
    Transaction tx2 = Mockito.mock(Transaction.class);
    Transaction tx3 = Mockito.mock(Transaction.class);

    Mockito.when(tx1.getGasPriceAsInteger()).thenReturn(BigInteger.valueOf(10));
    Mockito.when(tx2.getGasPriceAsInteger()).thenReturn(BigInteger.valueOf(11));
    Mockito.when(tx3.getGasPriceAsInteger()).thenReturn(BigInteger.valueOf(500000000));

    TxValidatorMinimuGasPriceValidator tvmgpv = new TxValidatorMinimuGasPriceValidator();


    Assert.assertTrue(tvmgpv.validate(tx1, null, null, BigInteger.valueOf(10), Long.MAX_VALUE, false));
    Assert.assertTrue(tvmgpv.validate(tx2, null, null, BigInteger.valueOf(10), Long.MAX_VALUE, false));
    Assert.assertTrue(tvmgpv.validate(tx3, null, null, BigInteger.valueOf(10), Long.MAX_VALUE, false));
}

@Test
public void testValidateResponseJsonErrorKnownException() throws IOException {
  Map<String, Object> json = new HashMap<String, Object>();
  json.put(HttpExceptionUtils.ERROR_EXCEPTION_JSON, IllegalStateException.class.getSimpleName());
  json.put(HttpExceptionUtils.ERROR_CLASSNAME_JSON, IllegalStateException.class.getName());
  json.put(HttpExceptionUtils.ERROR_MESSAGE_JSON, "EX");
  Map<String, Object> response = new HashMap<String, Object>();
  response.put(HttpExceptionUtils.ERROR_JSON, json);
  ObjectMapper jsonMapper = new ObjectMapper();
  String msg = jsonMapper.writeValueAsString(response);
  InputStream is = new ByteArrayInputStream(msg.getBytes());
  HttpURLConnection conn = Mockito.mock(HttpURLConnection.class);
  Mockito.when(conn.getErrorStream()).thenReturn(is);
  Mockito.when(conn.getResponseMessage()).thenReturn("msg");
  Mockito.when(conn.getResponseCode()).thenReturn(
      HttpURLConnection.HTTP_BAD_REQUEST);
  try {
    HttpExceptionUtils.validateResponse(conn, HttpURLConnection.HTTP_CREATED);
    Assert.fail();
  } catch (IllegalStateException ex) {
    Assert.assertEquals("EX", ex.getMessage());
  }
}

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

  gifHeader = Mockito.spy(new GifHeader());
  when(parser.parseHeader()).thenReturn(gifHeader);
  when(parserPool.obtain(isA(ByteBuffer.class))).thenReturn(parser);

  when(decoderFactory.build(isA(GifDecoder.BitmapProvider.class),
      eq(gifHeader), isA(ByteBuffer.class), anyInt()))
      .thenReturn(gifDecoder);

  List<ImageHeaderParser> parsers = new ArrayList<ImageHeaderParser>();
  parsers.add(new DefaultImageHeaderParser());

  options = new Options();
  decoder =
      new ByteBufferGifDecoder(
          RuntimeEnvironment.application,
          parsers,
          bitmapPool,
          new LruArrayPool(ARRAY_POOL_SIZE_BYTES),
          parserPool,
          decoderFactory);
}

@Test
public void testExecute_WhenDomainIsNotFound_ThrowsException() throws Exception {
    // Arrange.
    SecurityGroup sg = registerSecurityGroup(1L, "projectId", "projectName", 1L, "sgName");
    sg.addSecurityGroupMember(newSGMWithPort(1L));

    ostRegisterPorts(sg);

    // domain id null
    registerDomain(null, sg);

    this.exception.expect(Exception.class);
    this.exception
    .expectMessage(String.format("A domain was not found for the project: '%s' and Security Group: '%s",
            sg.getProjectName(), sg.getName()));

    CreatePortGroupTask task = this.factoryTask.create(sg);

    // Act.
    task.execute();

    // Assert.
    verify(this.em, Mockito.never()).merge(any());
}

@Test
public void testExecute_WhenPortGroupIsNotFound_ThrowsException() throws Exception {
    // Arrange.
    SecurityGroup sg = registerSecurityGroup(1L, "projectId", "projectName", 1L, "sgName");
    sg.addSecurityGroupMember(newSGMWithPort(1L));

    ostRegisterPorts(sg);

    registerDomain(UUID.randomUUID().toString(), sg);

    // network element/portGroup null
    NetworkElement ne = null;
    SdnRedirectionApi redirectionApi = registerNetworkElement(ne);
    registerNetworkRedirectionApi(redirectionApi, sg.getVirtualizationConnector());

    this.exception.expect(Exception.class);
    this.exception.expectMessage(String.format("RegisterNetworkElement failed to return PortGroup"));

    CreatePortGroupTask task = this.factoryTask.create(sg);
    // Act.
    task.execute();

    // Assert.
    verify(this.em, Mockito.never()).merge(any());
}

private static FacesContext createMockFacesContext () throws MalformedURLException {
    FacesContext ctx = Mockito.mock(FacesContext.class);
    CompositeELResolver cer = new CompositeELResolver();
    FacesELContext elc = new FacesELContext(cer, ctx);
    ServletRequest requestMock = Mockito.mock(ServletRequest.class);
    ServletContext contextMock = Mockito.mock(ServletContext.class);
    URL url = new URL("file:///");
    Mockito.when(contextMock.getResource(Matchers.anyString())).thenReturn(url);
    Mockito.when(requestMock.getServletContext()).thenReturn(contextMock);
    Answer<?> attrContext = new MockRequestContext();
    Mockito.when(requestMock.getAttribute(Matchers.anyString())).thenAnswer(attrContext);
    Mockito.doAnswer(attrContext).when(requestMock).setAttribute(Matchers.anyString(), Matchers.any());
    cer.add(new MockELResolver(requestMock));
    cer.add(new BeanELResolver());
    cer.add(new MapELResolver());
    Mockito.when(ctx.getELContext()).thenReturn(elc);
    return ctx;
}

@Test
@SuppressWarnings("unchecked")
public void testCreate() {
    DiscoveryService discoveryService = Mockito.mock(DiscoveryService.class);
    StreamId<Object> sourceStreamId = Mockito.mock(StreamId.class);

    Publisher<Object> sourceReactiveStream = Mockito.mock(Publisher.class);
    Publisher<Object> newReactiveStream = Mockito.mock(Publisher.class);
    Mockito.when(discoveryService.discover(sourceStreamId)).thenReturn(sourceReactiveStream);

    Function<List<Publisher<Object>>, Publisher<Object>> transformationFunction = Mockito.mock(Function.class);
    Mockito.when(transformationFunction.apply(Collections.singletonList(sourceReactiveStream)))
            .thenReturn(newReactiveStream);

    CompositionStreamId<Object, Object> compositionStreamId = new CompositionStreamId<>(sourceStreamId,
            transformationFunction);
    ErrorStreamPair<Object> optionalCompositionReactiveStream = compositionStreamFactory
            .create(compositionStreamId, discoveryService);

    assertThat(optionalCompositionReactiveStream.data()).isEqualTo(newReactiveStream);
    Mockito.verify(transformationFunction).apply(Collections.singletonList(sourceReactiveStream));
}

@Before
    public void setUp() throws Exception, LiRestResponseException {

        mContext = Mockito.mock(Activity.class);
        mMockSharedPreferences = Mockito.mock(SharedPreferences.class);
        resource = Mockito.mock(Resources.class);
        when(resource.getBoolean(anyInt())).thenReturn(true);
        when(mContext.getSharedPreferences(anyString(), anyInt())).thenReturn(mMockSharedPreferences);
        when(mMockSharedPreferences.getString(anyString(), anyString())).thenReturn("foobar");
        when(mContext.getResources()).thenReturn(resource);
        liSDKManager = LiSDKManager.init(mContext, TestHelper.getTestAppCredentials());
        liRestv2Client = mock(LiRestv2Client.class);
        MockitoAnnotations.initMocks(this);
//        when(liSDKManager.getTenant()).thenReturn("test");
        liClientManager = mock(LiClientManager.class);
        PowerMockito.mockStatic(LiRestv2Client.class);
        BDDMockito.given(LiRestv2Client.getInstance()).willReturn(liRestv2Client);
        PowerMockito.mockStatic(LiClientManager.class);
    }

@Test(groups = "SearchCategory.getCategory")
public void getCategory_should_return_valid_response() {
    try {
        PowerMockito
                .when(HttpUtils.doGet(Mockito.anyString(),
                        Matchers.<Map<String, String>> any()))
                .thenReturn(TEST_CATEGORY_RESPONSE);
        SearchCategory api = new SearchCategory(config);
        SearchCategoryRequest request = new SearchCategoryRequest()
                .setCategoryId(1043).setLocale("en-US");
        StockFileCategory category = api.getCategory(request);
        Assert.assertEquals(category.getName(), "Travel");
        Assert.assertEquals(category.getId().intValue(), 1043);
        Assert.assertEquals(category.getLink(), "/Category/travel/1043");
    } catch (Exception e) {
        Assert.fail("Didn't expect the exception here!", e);
    }
}

/**
 * V1 BOp V2 -> BOp V1 V2
 */
@SuppressWarnings("unchecked")
@Test
public void testBinaryOperator() {
    BinaryOperatorRepresentation<Integer> binaryOperator = Mockito.mock(BinaryOperatorRepresentation.class);
    Mockito.when(binaryOperator.isOperator()).thenReturn(true);
    ValueOperatorRepresentation<Integer> value1 = Mockito.mock(ValueOperatorRepresentation.class);
    ValueOperatorRepresentation<Integer> value2 = Mockito.mock(ValueOperatorRepresentation.class);
    INPUT.add(value1);
    INPUT.add(binaryOperator);
    INPUT.add(value2);
    ArrayList<IElementRepresentation<Integer>> RESULT = convertor.convert(INPUT);
    assertEquals(binaryOperator, RESULT.get(0));
    assertEquals(value1, RESULT.get(1));
    assertEquals(value2, RESULT.get(2));
}

@Test
public void init_Verifies_Permissions_NoPopupWhenGranted() throws Exception {
    ReactNativeCallEventsModule instance = getInstance();

    PowerMockito.mockStatic(ContextCompat.class);
    PowerMockito.when(ContextCompat.checkSelfPermission(mockActivity, Manifest.permission.READ_PHONE_STATE))
            .thenReturn(PackageManager.PERMISSION_GRANTED);

    PowerMockito.mockStatic(ActivityCompat.class);
    PowerMockito.doNothing().when(ActivityCompat.class);
    ActivityCompat.requestPermissions(mockActivity, new String[]{Manifest.permission.READ_PHONE_STATE}, 1);

    instance.init(false, false);

    PowerMockito.verifyStatic();
    ContextCompat.checkSelfPermission(mockActivity, Manifest.permission.READ_PHONE_STATE);

    PowerMockito.verifyStatic(Mockito.never());
    ActivityCompat.requestPermissions(Mockito.any(Activity.class), Mockito.any(String[].class), Mockito.anyInt());
}

@Before
public void setup() throws IOException, InterruptedException {

  // Prepare site.
  when(envVarsMock.get("JIRA_SITE")).thenReturn("LOCAL");
  when(envVarsMock.get("BUILD_URL")).thenReturn("http://localhost:8080/jira-testing/job/01");

  PowerMockito.mockStatic(Site.class);
  Mockito.when(Site.get(any())).thenReturn(siteMock);
  when(siteMock.getService()).thenReturn(jiraServiceMock);

  when(runMock.getCauses()).thenReturn(null);
  when(taskListenerMock.getLogger()).thenReturn(printStreamMock);
  doNothing().when(printStreamMock).println();

  final ResponseDataBuilder<Object> builder = ResponseData.builder();
  when(jiraServiceMock.updateIssue(anyString(), any()))
      .thenReturn(builder.successful(true).code(200).message("Success").build());

  when(contextMock.get(Run.class)).thenReturn(runMock);
  when(contextMock.get(TaskListener.class)).thenReturn(taskListenerMock);
  when(contextMock.get(EnvVars.class)).thenReturn(envVarsMock);
}

@Ignore
public void prepareRollback() throws Exception {
    // given
    ServiceInstance si = Mockito.spy(new ServiceInstance());
    si.setSubscriptionId("subscriptionId");
    si.setReferenceId("refId");
    String expectedXML = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><!DOCTYPE properties SYSTEM \"http://java.sun.com/dtd/properties.dtd\"><properties><entry key=\"ROLLBACK_SUBSCRIPTIONREF\">refId</entry><entry key=\"KEY2\">VALUE2</entry><entry key=\"ROLLBACK_SUBSCRIPTIONID\">subscriptionId</entry><entry key=\"KEY1\">VALUE1</entry></properties>";

    HashMap<String, String> params = new HashMap<>();
    params.put("KEY1", "VALUE1");
    params.put("KEY2", "VALUE2");

    Mockito.doReturn(params).when(si).getParameterMap();

    // when
    si.prepareRollback();

    // then
    assertEquals(expectedXML, removeFormatting(si.getRollbackParameters()));
}

private void waitForBlockReport(final DatanodeProtocolClientSideTranslatorPB mockNN)
    throws Exception {
  GenericTestUtils.waitFor(new Supplier<Boolean>() {
    @Override
    public Boolean get() {
      try {
        Mockito.verify(mockNN).blockReport(
            Mockito.<DatanodeRegistration>anyObject(),  
            Mockito.eq(FAKE_BPID),
            Mockito.<StorageBlockReport[]>anyObject(),
            Mockito.<BlockReportContext>anyObject());
        return true;
      } catch (Throwable t) {
        LOG.info("waiting on block report: " + t.getMessage());
        return false;
      }
    }
  }, 500, 10000);
}

@Test(groups = "Endpoints.getSearchFilesEndpoint")
public void getSearchFilesEndpoint_should_throw_stockexception_since_the_endpoint_properties_file_is_missing() {
    PowerMockito.spy(Endpoints.class);

    try {
        PowerMockito.doReturn(null).when(Endpoints.class,
                "getResourceAsStream", Mockito.any(String.class));
    } catch (Exception e1) {
        Assert.fail(
                "Couldn't mock the Endpoints.getResourceAsStream method!",
                e1);
    }

    try {
        new Endpoints(Environment.STAGE);

        Assert.fail("Didn't expect the endpoints to get constructed without exception!");
    } catch (StockException e) {
        Assert.assertEquals(e.getMessage(),
                "Could not load the endpoint properties file");
    }
}

private static void setupUploadMock(UploadService mockUploadService) {
  String jsonString = "{"
      + "'url' : 'https://s3.amazonaws.com/path',"
      + "'headers' : {"
      + "'Authorization' : 'auth_value',"
      + "'Content-MD5' : 'md5_value',"
      + "'x-amz-content-sha256' : 'sha256_value',"
      + "'x-amz-date' : 'date_value',"
      + "'x-amz-acl' : 'acl_value'"
      + "},"
      + "'location_url' : 'url'"
      + "}";

  Gson gson = new Gson();
  final UploadResponse response = gson.fromJson(jsonString, UploadResponse.class);
  Mockito
      .doAnswer(new Answer() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {
          return Calls.response(response);
        }
      })
      .when(mockUploadService)
      .upload(Mockito.<String, RequestBody>anyMap());
}

@Parameters()
public static Collection<Object[]> getTestData() throws EncryptionException {
    encryption = Mockito.mock(EncryptionApi.class);

    PowerMockito.mockStatic(StaticRegistry.class);
    Mockito.when(StaticRegistry.encryptionApi()).thenReturn(encryption);

    Mockito.when(encryption.encryptAESCTR("")).thenReturn(ENCRYPTED_PASSWORD);

    return Arrays.asList(new Object[][] {
        {UPDATE_OPENSTACK_NO_DEPLOYMENT_SPEC_VS,  createOpenstackNoDeploymentSpecGraph(UPDATE_OPENSTACK_NO_DEPLOYMENT_SPEC_VS), false},
        {UPDATE_OPENSTACK_DEPLOYMENT_SPEC_VS,  createOpenstackWithDeploymentSpecGraph(UPDATE_OPENSTACK_DEPLOYMENT_SPEC_VS), false},
        {UPDATE_OPENSTACK_LOCK_DEPLOYMENT_SPEC_FAILS_VS,  createOpenstacWhenLockingDeploymentSpecFailsGraph(UPDATE_OPENSTACK_LOCK_DEPLOYMENT_SPEC_FAILS_VS), false},
        {DELETE_OPENSTACK_WITH_DEPLOYMENT_SPECS_VS,  createDeleteOpenStackWithDeploymentSpecGraph(DELETE_OPENSTACK_WITH_DEPLOYMENT_SPECS_VS), false},
        {DELETE_OPENSTACK_WITH_OS_IMAGE_REF_VS,  createDeleteOpenStackWithOSImageRefGraph(DELETE_OPENSTACK_WITH_OS_IMAGE_REF_VS), false},
        {DELETE_OPENSTACK_WITH_OS_FLAVOR_REF_VS,  createDeleteOpenStackWithOSFlavorRefGraph(DELETE_OPENSTACK_WITH_OS_FLAVOR_REF_VS), false},
    });
}

@Test
public void setUserCredentialsInContext_INTERNAL() {
    // given
    Map<String, Setting> settings = getSettingsForMode("INTERNAL");
    BindingProvider client = Mockito.mock(BindingProvider.class);
    Map<String, String> context = new HashMap<>();
    Mockito.doReturn(context).when(client).getRequestContext();

    // when
    besDAO.setUserCredentialsInContext(client, USER, PASSWORD, settings);

    // then
    assertNull(client.getRequestContext().get(
            "username"));
    assertNull(client.getRequestContext().get(
            "password"));
    assertEquals(
            USER,
            client.getRequestContext().get(
                    BindingProvider.USERNAME_PROPERTY));
    assertEquals(
            PASSWORD,
            client.getRequestContext().get(
                    BindingProvider.PASSWORD_PROPERTY));
}

/**
 * Tests the close method of the transactional writer.
 */
@Test
public void testTransactionalWriterClose() throws Exception {
    try (TransactionalWriterTestContext context = new TransactionalWriterTestContext(PravegaWriterMode.EXACTLY_ONCE)) {
        Transaction<Integer> trans = context.prepareTransaction();
        try {
            try (StreamSinkOperatorTestHarness<Integer> testHarness = createTestHarness(context.sinkFunction)) {
                testHarness.open();

                // prepare a worst-case situation that exercises the exception handling aspect of close
                Mockito.doThrow(new IntentionalRuntimeException()).when(trans).abort();
                Mockito.doThrow(new IntentionalRuntimeException()).when(context.pravegaWriter).close();
            }
            Assert.fail("expected an exception");
        } catch (IntentionalRuntimeException e) {
            Assert.assertEquals(1, e.getSuppressed().length);
            Assert.assertTrue(e.getSuppressed()[0] instanceof IntentionalRuntimeException);
        }

        // verify that the transaction was aborted and the writer closed
        verify(trans).abort();
        verify(context.pravegaWriter).close();
    }
}

@Test
public void testFailbackToFaultyServiceFails() throws Exception {
  DummyHAService svc1 = new DummyHAService(HAServiceState.ACTIVE, svc1Addr);
  Mockito.doThrow(new ServiceFailedException("Failed!"))
      .when(svc1.proxy).transitionToActive(anyReqInfo());
  DummyHAService svc2 = new DummyHAService(HAServiceState.STANDBY, svc2Addr);
  Mockito.doThrow(new ServiceFailedException("Failed!"))
      .when(svc2.proxy).transitionToActive(anyReqInfo());

  svc1.fencer = svc2.fencer = setupFencer(AlwaysSucceedFencer.class.getName());

  try {
    doFailover(svc1, svc2, false, false);
    fail("Failover to already active service");
  } catch (FailoverFailedException ffe) {
    // Expected
  }

  assertEquals(HAServiceState.STANDBY, svc1.state);
  assertEquals(HAServiceState.STANDBY, svc2.state);
}

public void testCreatePolicySetsForMultipleZones() {
    PolicySet issuer1PolicySet = this.jsonUtils.deserializeFromFile("set-with-1-policy.json", PolicySet.class);
    PolicySet issuer2PolicySet = this.jsonUtils
            .deserializeFromFile("policy-set-with-one-policy-one-condition.json", PolicySet.class);

    Mockito.when(this.mockZoneResolver.getZoneEntityOrFail()).thenReturn(this.zone1);
    this.policyService.upsertPolicySet(issuer1PolicySet);

    Mockito.when(this.mockZoneResolver.getZoneEntityOrFail()).thenReturn(this.zone2);
    this.policyService.upsertPolicySet(issuer2PolicySet);

    Assert.assertEquals(this.policyService.getAllPolicySets().size(), 1);

    this.policyService.deletePolicySet(issuer2PolicySet.getName());
    // need this to delete issuer1PolicySet properly (policy-set-id and
    // zone_id are used to find the row)
    Mockito.when(this.mockZoneResolver.getZoneEntityOrFail()).thenReturn(this.zone1);
    this.policyService.deletePolicySet(issuer1PolicySet.getName());
    Assert.assertEquals(this.policyService.getAllPolicySets().size(), 0);

}

@Test
public void shouldStopMonitorOnConfigurationChangedIfQueueRemoved() {
    this.scheduler.register(this.listenerA1);
    this.scheduler.register(this.listenerB1);
    Mockito.verify(this.factory).createMonitor(this.executor, this.queueA);
    Mockito.verify(this.factory).createMonitor(this.executor, this.queueB);
    Mockito.verify(this.monitorA, times(1)).add(this.listenerA1);
    Mockito.verify(this.monitorB, times(1)).add(this.listenerB1);
    Mockito.when(this.provider.getSqsQueue(UUID_B)).thenReturn(null);

    this.scheduler.onConfigurationChanged(new ConfigurationChangedEvent());

    Mockito.verifyNoMoreInteractions(this.factory);
    Mockito.verify(this.monitorA).getQueue();
    Mockito.verify(this.monitorA).isShutDown();
    Mockito.verify(this.monitorB).shutDown();
    Mockito.verifyNoMoreInteractions(this.monitorA);
    Mockito.verifyNoMoreInteractions(this.monitorB);
}

@SuppressWarnings({ "unchecked", "serial" })
@Test
public void testGetEvent_AppIdIsNull() throws Exception {
    GetEventRequestVO getEventRequestVO = ImmutableGetEventRequestVO.builder()
            .setAppId((String) null)
            .setEventId("eventId")
            .setIdentityMap(new HashMap<String, Object>() {{put("uuid", "069a79f4-44e9-4726-a5be-fca90e38aaf5");}})
            .setAfterEventId("123456789")
            .setBeforeEventId("123456789")
            .setLimit("50")
            .build();

    GetEventResponseVO returnedGetEventResponseVO = ImmutableGetEventResponseVO.builder().build();
    GetEventResponseVO[] returnedGetEventResponseArray = new GetEventResponseVO[] {returnedGetEventResponseVO};

    JsonRpcUtils mockJsonRpcUtils = PowerMockito.mock(JsonRpcUtils.class);
    PowerMockito.whenNew(JsonRpcUtils.class).withNoArguments().thenReturn(mockJsonRpcUtils);
    Mockito.when(mockJsonRpcUtils.sendJsonRpcRequest(Mockito.anyString(), Mockito.any(), Mockito.anyString(), Mockito.isA(Map.class))).thenReturn(returnedGetEventResponseArray);

    eventService = new EventsServiceImpl(enjinConfig);
    GetEventResponseVO[] getEventResponseVO = eventService.getEvent(getEventRequestVO);
    assertThat(getEventResponseVO).isNotNull();

    PowerMockito.verifyNew(JsonRpcUtils.class, Mockito.times(1)).withNoArguments();
    Mockito.verify(mockJsonRpcUtils, Mockito.times(1)).sendJsonRpcRequest(Mockito.anyString(), Mockito.any(), Mockito.anyString(), Mockito.isA(Map.class));
}

@Before
    public void setup()
            throws Exception {
//        TestJMeterUtils.createJmeterEnv();

        parserMock = Mockito.mock(Parser.class);
        sampler = new HlsSampler();
        sampler.setURLData("http://www.mock.com/path");
        sampler.setResData("640x360");
        sampler.setNetworkData("1395723");
        sampler.setBandwidthType("customBandwidth");
        sampler.setResolutionType("customResolution");
        sampler.setUrlVideoType("Bandwidth");
        sampler.setPRotocol("https");
        sampler.setPlaySecondsData("20");
        sampler.setVideoDuration(true);
        sampler.setParser(parserMock);
        sampler.setName("Test");
    }

@SuppressWarnings({"unchecked", "serial"})
@Test
public void testCreateIdentity_Success() throws Exception {
    CreateIdentityRequestVO createIdentityRequestVO = ImmutableCreateIdentityRequestVO.builder()
            .setAuth("auth")
            .setIdentityMap(new HashMap<String, Object>() {{
                put("key", "value");
            }})
            .build();

    CreateIdentityResponseVO returnedCreateIdentityResponseVO = ImmutableCreateIdentityResponseVO.builder().build();

    JsonRpcUtils mockJsonRpcUtils = PowerMockito.mock(JsonRpcUtils.class);
    PowerMockito.whenNew(JsonRpcUtils.class).withNoArguments().thenReturn(mockJsonRpcUtils);
    Mockito.when(mockJsonRpcUtils.sendJsonRpcRequest(Mockito.anyString(), Mockito.any(), Mockito.anyString(), Mockito.isA(Map.class))).thenReturn(returnedCreateIdentityResponseVO);

    identitiesAsyncService = new IdentitiesAsyncServiceImpl(enjinConfig);
    CompletableFuture<CreateIdentityResponseVO> createIdentityResponseCompletableFutureVO = identitiesAsyncService.createIdentityAsync(createIdentityRequestVO);
    assertThat(createIdentityResponseCompletableFutureVO).isNotNull();
    CreateIdentityResponseVO createIdentityResponseVO = createIdentityResponseCompletableFutureVO.get();
    assertThat(createIdentityResponseVO).isNotNull();

    PowerMockito.verifyNew(JsonRpcUtils.class, Mockito.times(1)).withNoArguments();
    Mockito.verify(mockJsonRpcUtils, Mockito.times(1)).sendJsonRpcRequest(Mockito.anyString(), Mockito.any(), Mockito.anyString(), Mockito.isA(Map.class));
}

private static SecurityGroupInterface createSgi(String sgiId, String sgiName, boolean isMarkedForDeletion,
        String tag, String policyId) {
    SecurityGroupInterface sgi = Mockito.mock(SecurityGroupInterface.class);
    Mockito.when(sgi.getMgrSecurityGroupInterfaceId()).thenReturn(sgiId);
    Mockito.when(sgi.getName()).thenReturn(sgiName);
    Mockito.when(sgi.getMarkedForDeletion()).thenReturn(isMarkedForDeletion);
    Mockito.when(sgi.getTag()).thenReturn(tag);
    Policy policy = Mockito.mock(Policy.class);
    Set<Policy> policySet = new HashSet<>();
    policySet.add(policy);
    Mockito.when(sgi.getMgrPolicies()).thenReturn(policySet);
    Mockito.when(policy.getMgrPolicyId()).thenReturn(policyId);

    return sgi;

}

@Test
public void step_3_generate_block() throws Exception {

    PeerContext ctx = new PeerContext(GENERATOR, mockTimeProvider);
    Block lastBlock = ctx.context.getInstance().getBlockchainService().getLastBlock();

    Mockito.when(mockTimeProvider.get()).thenReturn(lastBlock.getTimestamp() + 200);

    ctx.generateBlockForNow();

    Assert.assertNotEquals("Is new block generated", lastBlock.getID(),
            ctx.context.getInstance().getBlockchainService().getLastBlock().getID());
    Assert.assertFalse("Generator stopped", ctx.context.getInstance().getGenerator().isGenerationAllowed());

    Block generatedBlock = ctx.context.getInstance().getBlockchainService()
            .getBlock(ctx.context.getInstance().getBlockchainService().getLastBlock().getID());

    Assert.assertEquals("DB store new block ID", generatedBlock.getID(),
            ctx.context.getInstance().getBlockchainService().getLastBlock().getID());
    Assert.assertEquals("Period is 180 sec", lastBlock.getTimestamp() + 180, generatedBlock.getTimestamp());
}

@Test
public void testNodesBlockRenderForNodeLabelFilterWithAnyLabel() {
  NodesBlock nodesBlock = injector.getInstance(NodesBlock.class);
  nodesBlock.set("node.label", "*");
  nodesBlock.render();
  PrintWriter writer = injector.getInstance(PrintWriter.class);
  WebAppTests.flushOutput(injector);

  Mockito.verify(
      writer,
      Mockito.times(numberOfRacks * numberOfNodesPerRack
          * numberOfActualTableHeaders + numberOfThInMetricsTable)).print(
      "<td");
}

/**
 * Verify that, when the callback fails to enter active state, after
 * a ZK disconnect (i.e from the StatCallback), that the elector rejoins
 * the election after sleeping for a short period.
 */
@Test
public void testFailToBecomeActiveAfterZKDisconnect() throws Exception {
  mockNoPriorActive();
  elector.joinElection(data);
  Assert.assertEquals(0, elector.sleptFor);

  elector.processResult(Code.CONNECTIONLOSS.intValue(), ZK_LOCK_NAME, mockZK,
      ZK_LOCK_NAME);
  Mockito.verify(mockZK, Mockito.times(2)).create(ZK_LOCK_NAME, data,
      Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL, elector, mockZK);

  elector.processResult(Code.NODEEXISTS.intValue(), ZK_LOCK_NAME, mockZK,
      ZK_LOCK_NAME);
  verifyExistCall(1);

  Stat stat = new Stat();
  stat.setEphemeralOwner(1L);
  Mockito.when(mockZK.getSessionId()).thenReturn(1L);

  // Fake failure to become active from within the stat callback
  Mockito.doThrow(new ServiceFailedException("fail to become active"))
      .when(mockApp).becomeActive();
  elector.processResult(Code.OK.intValue(), ZK_LOCK_NAME, mockZK, stat);
  Mockito.verify(mockApp, Mockito.times(1)).becomeActive();

  // should re-join
  Mockito.verify(mockZK, Mockito.times(3)).create(ZK_LOCK_NAME, data,
      Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL, elector, mockZK);
  Assert.assertEquals(2, count);
  Assert.assertTrue(elector.sleptFor > 0);
}

@Test
public void shouldDoNothingOnClose() {
    final DefaultTrackerClient trackerClient = Mockito.mock(DefaultTrackerClient.class);
    Mockito.doCallRealMethod().when(trackerClient).close();
    try {
        trackerClient.close();
    } catch (final Throwable ignored) {
        fail("should not fail to close.");
    }
}

@Test
public void testConstructor() throws Exception {
    final ModuleInfoRegistry reg = mock(ModuleInfoRegistry.class);
    final SchemaContextProvider prov = mock(SchemaContextProvider.class);
    doReturn("string").when(prov).toString();
    final BundleContext ctxt = mock(BundleContext.class);
    final ServiceRegistration<?> servReg = mock(ServiceRegistration.class);
    doReturn(servReg).when(ctxt).registerService(any(Class.class), any(SchemaContextProvider.class),
            any(Dictionary.class));
    doReturn(servReg).when(ctxt).registerService(Mockito.anyString(), any(Object.class), any(Dictionary.class));
    doNothing().when(servReg).setProperties(any(Dictionary.class));

    final ClassLoadingStrategy classLoadingStrat = mock(ClassLoadingStrategy.class);
    final BindingContextProvider codecRegistryProvider = mock(BindingContextProvider.class);
    doNothing().when(codecRegistryProvider).update(classLoadingStrat, prov);
    final BindingRuntimeContext bindingRuntimeContext = mock(BindingRuntimeContext.class);
    doReturn("B-runtime-context").when(bindingRuntimeContext).toString();
    doReturn(bindingRuntimeContext).when(codecRegistryProvider).getBindingContext();

    final RefreshingSCPModuleInfoRegistry scpreg = new RefreshingSCPModuleInfoRegistry(reg, prov, classLoadingStrat,
            this.sourceProvider, codecRegistryProvider, ctxt);

    doNothing().when(servReg).unregister();

    final YangModuleInfo modInfo = mock(YangModuleInfo.class);
    doReturn("").when(modInfo).toString();
    final ObjectRegistration<YangModuleInfo> ymi = mock(ObjectRegistration.class);
    doReturn(ymi).when(reg).registerModuleInfo(modInfo);

    scpreg.registerModuleInfo(modInfo);
    scpreg.updateService();

    verify(codecRegistryProvider).update(classLoadingStrat, prov);

    scpreg.close();

    Mockito.verify(servReg, Mockito.times(1)).setProperties(any(Dictionary.class));
    Mockito.verify(servReg, Mockito.times(1)).unregister();
}

private BlockInfoContiguous addBlockOnNodes(long blockId, List<DatanodeDescriptor> nodes) {
  BlockCollection bc = Mockito.mock(BlockCollection.class);
  Mockito.doReturn((short)3).when(bc).getBlockReplication();
  BlockInfoContiguous blockInfo = blockOnNodes(blockId, nodes);

  bm.blocksMap.addBlockCollection(blockInfo, bc);
  return blockInfo;
}

@Test
public void algorithmCompatibleWithMethod_rsa() {
    // given
    SamlKeySelector keySelector = mock(SamlKeySelector.class,
            Mockito.CALLS_REAL_METHODS);

    // when
    boolean result = keySelector.algorithmCompatibleWithMethod(
            SignatureMethod.RSA_SHA1, keySelector.ALGORITHM_RSA);

    // then
    assertTrue(result);
}

@Test
public void testOnDisconnectCancel() throws InterruptedException {
  MockConnectionFactory connFactory = new MockConnectionFactory();
  connFactory.persistentConn.onReady(System.currentTimeMillis(), "last-session-id");
  connFactory.persistentConn.onDataMessage(
      ImmutableMap.<String, Object>of("r", 1, "b", ImmutableMap.of("s", "ok")));

  RequestResultCallback callback = Mockito.mock(RequestResultCallback.class);
  connFactory.persistentConn.onDisconnectCancel(ImmutableList.of("put"), callback);

  // Write should not be sent until auth us successful
  assertEquals(3, connFactory.outgoing.size());
  assertEquals("oc", connFactory.outgoing.get(2).getAction());
}

@Test(expected = OperationNotPermittedException.class)
public void resumeService_CatalogEntriesEmpty() throws Exception {
    try {
        product.setCatalogEntries(new ArrayList<CatalogEntry>());
        bean.resumeService(voService);
    } finally {
        Mockito.verify(dataServiceMock, Mockito.never()).flush();
    }
}

@Test(expected = OutOfBoundsException.class)
public void insertObjectOnBorder5_5_thenMoveDown_shouldThrowOutOfBoundsException()
{
    Mockito
    .when(object.getCenter())
    .thenReturn(calcPosition(5, 5)); 
    collisionMap.insert(object);
    collisionMap.moveDown(object);
}

@Test
public void testFailoverWithFencerConfigured() throws Exception {
  Mockito.doReturn(STANDBY_READY_RESULT).when(mockProtocol).getServiceStatus();
  HdfsConfiguration conf = getHAConf();
  conf.set(DFSConfigKeys.DFS_HA_FENCE_METHODS_KEY, getFencerTrueCommand());
  tool.setConf(conf);
  assertEquals(0, runTool("-failover", "nn1", "nn2"));
}

/**
 * Test encrypt.
 */
@Test
public void encryptAsNeeded() {
    final StringEncryptor stringEncryptor = Mockito.mock(StringEncryptor.class);
    Mockito.when(stringEncryptor.decrypt("value")).thenThrow(new EncryptionOperationNotPossibleException());
    Mockito.when(stringEncryptor.encrypt("value")).thenReturn("encrypted");
    final CryptoHelper securityHelper = new CryptoHelper();
    securityHelper.setEncryptor(stringEncryptor);
    Assert.assertEquals("encrypted", securityHelper.encryptAsNeeded("value"));
}

@Override
@Before
public void testInitialize() throws Exception {
    super.testInitialize();
    this.service.validator = this.validatorMock;
    this.request = new BaseIdRequest();
    Mockito.when(this.service.validator.create(this.em)).thenReturn(this.validatorMock);
}

@Before
public void testInitialize() throws VmidcException {
    MockitoAnnotations.initMocks(this);
    this.em = InMemDB.getEntityManagerFactory().createEntityManager();

    this.txControl.setEntityManager(this.em);
    Mockito.when(this.dbMgr.getTransactionalEntityManager()).thenReturn(this.em);
    Mockito.when(this.dbMgr.getTransactionControl()).thenReturn(this.txControl);
    registerKubernetesPods(this.sgm.getLabel(), MATCHING_PODS);
    persist(this.sgm, this.em);
}