Java Mockito.reset方法代码示例

import org.mockito.Mockito; //导入方法依赖的package包/类
private void testManagementOperationErrors() throws Exception {
  HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
  HttpServletResponse response = Mockito.mock(HttpServletResponse.class);
  Mockito.when(request.getQueryString()).thenReturn(
      DelegationTokenAuthenticator.OP_PARAM + "=" +
          DelegationTokenAuthenticator.DelegationTokenOperation.
              GETDELEGATIONTOKEN.toString()
  );
  Mockito.when(request.getMethod()).thenReturn("FOO");
  Assert.assertFalse(handler.managementOperation(null, request, response));
  Mockito.verify(response).sendError(
      Mockito.eq(HttpServletResponse.SC_BAD_REQUEST),
      Mockito.startsWith("Wrong HTTP method"));

  Mockito.reset(response);
  Mockito.when(request.getMethod()).thenReturn(
      DelegationTokenAuthenticator.DelegationTokenOperation.
          GETDELEGATIONTOKEN.getHttpMethod()
  );
  Assert.assertFalse(handler.managementOperation(null, request, response));
  Mockito.verify(response).setStatus(
      Mockito.eq(HttpServletResponse.SC_UNAUTHORIZED));
  Mockito.verify(response).setHeader(
      Mockito.eq(KerberosAuthenticator.WWW_AUTHENTICATE),
      Mockito.eq("mock"));
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testWriteFirstChunkFailed() throws IOException {
    InputSource inputSource = Mockito.mock(InputSource.class);
    doThrow(IOException.class).when(inputSource).open();

    when(gatt.getService(eq(serviceUUID))).thenReturn(gattService);
    when(gattService.getCharacteristic(characteristicUUID)).thenReturn(gattCharacteristic);

    WriteCommand writeCommand = new WriteCommand(
            serviceUUID,
            characteristicUUID,
            BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT,
            inputSource,
            commandObserver);

    writeCommand.execute(device, operationCommandObserver, gatt);
    CommandResult result = CommandResult.createErrorResult(characteristicUUID, BluetoothGatt.GATT_FAILURE);
    verify(commandObserver, times(1)).finished(eq(writeCommand), refEq(result, "timestamp"));
    verify(operationCommandObserver, times(1)).finished(eq(writeCommand), refEq(result, "timestamp"));
    Mockito.reset(commandObserver, operationCommandObserver, inputSource);

    when(inputSource.nextChunk()).thenThrow(IOException.class);
    writeCommand.execute(device, operationCommandObserver, gatt);
    verify(commandObserver, times(1)).finished(eq(writeCommand), refEq(result, "timestamp"));
    verify(operationCommandObserver, times(1)).finished(eq(writeCommand), refEq(result, "timestamp"));
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
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));
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private PrivilegedOperation capturePrivilegedOperation()
    throws PrivilegedOperationException {
  ArgumentCaptor<PrivilegedOperation> opCaptor = ArgumentCaptor.forClass(
      PrivilegedOperation.class);

  //single invocation expected
  //due to type erasure + mocking, this verification requires a suppress
  // warning annotation on the entire method
  verify(mockExecutor, times(1))
      .executePrivilegedOperation(anyList(), opCaptor.capture(), any(
          File.class), any(Map.class), eq(false));

  //verification completed. we need to isolate specific invications.
  // hence, reset mock here
  Mockito.reset(mockExecutor);

  return opCaptor.getValue();
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testValidateAlreadyCached() throws IOException{
	byte[] bytes = "{ 'key': 'value' }".getBytes(StandardCharsets.UTF_8);
	HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
	Mockito.doReturn(new CachingServletInputStream(new ByteArrayInputStream(bytes))).when(request).getInputStream();
	Mockito.doReturn(toParamMap(params)).when(request).getParameterMap();
	CachingHttpServletRequest cachingRequest = CachingHttpServletRequest.getOrCreate(request);
	Assert.assertNotNull(cachingRequest.getContent());
	Mockito.reset(request);

	SecurityValidationResult result = validator.validate(cachingRequest);
	Mockito.verify(request, Mockito.never()).getInputStream();
	Assert.assertSame(result.getWrappedRequest(), cachingRequest);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void doesntSetIfEmptyProperties() {
    Mockito.reset(request);
    mavenGoal.setProperties(new Properties());
    mavenGoal.execution(null, null);
    verify(request, times(0)).setProperties((Properties)any());
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void addMultipleEventHandlerTest() {
    AbstractPlayerEventHandlerImpl abstractEventHandlers = getPlayerEventHandler();
    PlayerEventHandler handler = mock(PlayerEventHandler.class);

    abstractEventHandlers.addHandler(handler, PlayerEvent.getType(PlayerEventTypes.LOAD_PAGE_VIEW));

    // test
    PlayerEvent event = new PlayerEvent(PlayerEventTypes.LOAD_PAGE_VIEW);
    abstractEventHandlers.fireEvent(event);
    verify(handler).onPlayerEvent(event);
    Mockito.reset(handler);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testConnect() throws Exception {
  // The test connects the plugin to the ledger by default, so disconnect first.
  this.mockLedgerPlugin.disconnect();
  Mockito.reset(ledgerPluginEventHandlerMock);

  this.mockLedgerPlugin.connect();
  assertThat(mockLedgerPlugin.isConnected(), is(true));

  verify(ledgerPluginEventHandlerMock).onConnect(any());
  verifyNoMoreInteractions(ledgerPluginEventHandlerMock);
  assertThat(mockLedgerPlugin.getSimulatedLedger().getConnections().size(), is(1));
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
private void checkFatalsAndReset() throws Exception {
  for (int i = 0; i < NUM_ELECTORS; i++) {
    Mockito.verify(cbs[i], Mockito.never()).notifyFatalError(
        Mockito.anyString());
    Mockito.reset(cbs[i]);
  }
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testInvokeRequest() {
    instance.setFlowRequestsInvoker(requestInvoker);
    doReturn(null).when(instance)
            .getCurrentGroupIdentifier();

    instance.isSelected = true;
    instance.invokeRequest();
    verify(requestInvoker).invokeRequest(Matchers.any(FlowRequest.Continue.class));

    Mockito.reset(requestInvoker);
    instance.isSelected = false;
    instance.invokeRequest();
    verify(requestInvoker).invokeRequest(Matchers.any(FlowRequest.ShowAnswers.class));
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
/**
 * Test to make sure that we don't attempt to ask the delegate whether or not we should preserve a
 * directory.
 * @throws Exception on failure
 */
@Test
public void testDoesNotCheckDirectories() throws Exception {
  Stoppable stop = new StoppableImplementation();
  Configuration conf = UTIL.getConfiguration();
  Path testDir = UTIL.getDataTestDir();
  FileSystem fs = UTIL.getTestFileSystem();
  String confKey = "hbase.test.cleaner.delegates";
  conf.set(confKey, AlwaysDelete.class.getName());

  AllValidPaths chore = new AllValidPaths("test-file-cleaner", stop, conf, fs, testDir, confKey);
  // spy on the delegate to ensure that we don't check for directories
  AlwaysDelete delegate = (AlwaysDelete) chore.cleanersChain.get(0);
  AlwaysDelete spy = Mockito.spy(delegate);
  chore.cleanersChain.set(0, spy);

  // create the directory layout in the directory to clean
  Path parent = new Path(testDir, "parent");
  Path file = new Path(parent, "someFile");
  fs.mkdirs(parent);
  assertTrue("Test parent didn't get created.", fs.exists(parent));
  // touch a new file
  fs.create(file).close();
  assertTrue("Test file didn't get created.", fs.exists(file));
  
  FileStatus fStat = fs.getFileStatus(parent);
  chore.chore();
  // make sure we never checked the directory
  Mockito.verify(spy, Mockito.never()).isFileDeletable(fStat);
  Mockito.reset(spy);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Before
public void before() {
    Mockito.reset(candidateMatchPair);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Before
public void setup() {
    Mockito.reset(amazonDynamoDB);
    scanResult = new ScanResult();
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
/**
 * Injects a failure on all storage directories while saving namespace.
 *
 * @param restoreStorageAfterFailure if true, will try to save again after
 *   clearing the failure injection
 */
public void doTestFailedSaveNamespace(boolean restoreStorageAfterFailure)
throws Exception {
  Configuration conf = getConf();
  NameNode.initMetrics(conf, NamenodeRole.NAMENODE);
  DFSTestUtil.formatNameNode(conf);
  FSNamesystem fsn = FSNamesystem.loadFromDisk(conf);

  // Replace the FSImage with a spy
  final FSImage originalImage = fsn.getFSImage();
  NNStorage storage = originalImage.getStorage();
  storage.close(); // unlock any directories that FSNamesystem's initialization may have locked

  NNStorage spyStorage = spy(storage);
  originalImage.storage = spyStorage;
  FSImage spyImage = spy(originalImage);
  Whitebox.setInternalState(fsn, "fsImage", spyImage);

  spyImage.storage.setStorageDirectories(
      FSNamesystem.getNamespaceDirs(conf), 
      FSNamesystem.getNamespaceEditsDirs(conf));

  doThrow(new IOException("Injected fault: saveFSImage")).
      when(spyImage).saveFSImage(
          (SaveNamespaceContext)anyObject(),
          (StorageDirectory)anyObject(), (NameNodeFile) anyObject());

  try {
    doAnEdit(fsn, 1);

    // Save namespace
    fsn.setSafeMode(SafeModeAction.SAFEMODE_ENTER);
    try {
      fsn.saveNamespace();
      fail("saveNamespace did not fail even when all directories failed!");
    } catch (IOException ioe) {
      LOG.info("Got expected exception", ioe);
    }
    
    // Ensure that, if storage dirs come back online, things work again.
    if (restoreStorageAfterFailure) {
      Mockito.reset(spyImage);
      spyStorage.setRestoreFailedStorage(true);
      fsn.saveNamespace();
      checkEditExists(fsn, 1);
    }

    // Now shut down and restart the NN
    originalImage.close();
    fsn.close();
    fsn = null;

    // Start a new namesystem, which should be able to recover
    // the namespace from the previous incarnation.
    fsn = FSNamesystem.loadFromDisk(conf);

    // Make sure the image loaded including our edits.
    checkEditExists(fsn, 1);
  } finally {
    if (fsn != null) {
      fsn.close();
    }
  }
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@BeforeMethod
public void beforeMethod() {
    Mockito.reset(this.spyGateway);
}