Java Mockito.verifyNoMoreInteractions方法代码示例

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testOnDrag() {
    Mockito.verify(mMockController).getClipDataHelper();

    assertThat(mOnDragToTrashListener.onDrag(null, mBlockDragStartFromWorkspace)).isTrue();
    Mockito.verifyNoMoreInteractions(mMockController);

    mOnDragToTrashListener.onDrag(null, mBlockDragEntered);
    Mockito.verifyNoMoreInteractions(mMockController);

    mOnDragToTrashListener.onDrag(null, mBlockDragLocation);
    Mockito.verifyNoMoreInteractions(mMockController);

    mOnDragToTrashListener.onDrag(null, mBlockDragExited);
    Mockito.verifyNoMoreInteractions(mMockController);

    assertThat(mOnDragToTrashListener.onDrag(null, mBlockDrop)).isTrue();
    Mockito.verify(mMockController)
            .trashRootBlock(Mockito.any(Block.class));

    mOnDragToTrashListener.onDrag(null, mBlockDragEnded);
    Mockito.verifyNoMoreInteractions(mMockController);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@GwtIncompatible // Mockito
public void testOnSuccessThrowsError() throws Exception {
  class TestError extends Error {}
  TestError error = new TestError();
  String result = "result";
  SettableFuture<String> future = SettableFuture.create();
  @SuppressWarnings("unchecked") // Safe for a mock
  FutureCallback<String> callback = Mockito.mock(FutureCallback.class);
  addCallback(future, callback, directExecutor());
  Mockito.doThrow(error).when(callback).onSuccess(result);
  try {
    future.set(result);
    fail("Should have thrown");
  } catch (TestError e) {
    assertSame(error, e);
  }
  assertEquals(result, future.get());
  Mockito.verify(callback).onSuccess(result);
  Mockito.verifyNoMoreInteractions(callback);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testHandleReceiveRemoveEndpoint() throws Exception {
    final Map<Address, Optional<RemoteRpcEndpoint>> endpoints = ImmutableMap.of(
            endpointAddress, Optional.empty());
    testActorRef.tell(new UpdateRemoteEndpoints(endpoints), ActorRef.noSender());
    Mockito.verifyNoMoreInteractions(service, oldReg, newReg);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void setTypeFaceForDismissButtonNullTypeFaceTest() {
    Mockito.when(mTypeFaceProvider.getTypeFaceFromAssets(Matchers.anyString())).thenReturn(null);

    mPopUpCoachMarkPresenter.setTypeFaceForDismissButton(Matchers.anyString());

    Mockito.verify(mTypeFaceProvider, Mockito.times(1)).getTypeFaceFromAssets(Matchers.anyString());
    Mockito.verify(mPopUpCoachMarkPresentation, Mockito.times(0))
            .setTypeFaceForDismissButton((Typeface) Matchers.anyObject());

    Mockito.verifyNoMoreInteractions(mPopUpCoachMarkPresentation);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test public void batchInvokedWithTwoElements() {
  Funnel.Batch<Integer, String> toSpell = funnel.through(batch::send);
  toSpell.accept(1);
  toSpell.accept(2);
  when(batch.send(asList(1, 2))).thenReturn(asList("one", "two"));
  assertThat(funnel.run()).containsExactly("one", "two").inOrder();
  Mockito.verify(batch).send(asList(1, 2));
  Mockito.verifyNoMoreInteractions(batch);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testClientFromFactory() {
    AmazonSQSClient sqs = Mockito.mock(AmazonSQSClient.class);
    SqsMessage m = new SqsMessage(RECEIPT_HANDLE, new byte[] {}, 1000, Optional.empty(),
            new SqsMessage.Service(Optional.empty(), () -> sqs, Optional.empty(), sqs, QUEUE,
                    Optional.empty()));
    Mockito.when(sqs.deleteMessage(QUEUE, RECEIPT_HANDLE))
            .thenReturn(new DeleteMessageResult());
    m.deleteMessage(Client.FROM_FACTORY);
    InOrder inorder = Mockito.inOrder(sqs);
    inorder.verify(sqs, Mockito.times(1)).deleteMessage(QUEUE, RECEIPT_HANDLE);
    inorder.verify(sqs, Mockito.times(1)).shutdown();
    Mockito.verifyNoMoreInteractions(sqs);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testBeforeParse() {
    Document parse = XMLParser.parse(Templates.TEMPLATE_WITHOUT_CONTENT_WITH_FULLSCREEN);
    instance = spy(factory.getImgTemplateParser(parse.getDocumentElement(), moduleSocket));
    instance.beforeParse(mock(Node.class), null);
    verify(instance).beforeParse(Matchers.any(Node.class), Matchers.any(Widget.class));
    Mockito.verifyNoMoreInteractions(instance);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test public void batchInvokedWithAftereffect() {
  Funnel.Batch<Integer, String> toSpell = funnel.through(batch::send);
  AtomicReference<String> spelled = new AtomicReference<>();
  toSpell.accept(1, spelled::set);
  toSpell.accept(2);
  when(batch.send(asList(1, 2))).thenReturn(asList("one", "two"));
  assertThat(funnel.run()).containsExactly("one", "two").inOrder();
  assertThat(spelled.get()).isEqualTo("one");
  Mockito.verify(batch).send(asList(1, 2));
  Mockito.verifyNoMoreInteractions(batch);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void shouldNotSendDeleteRequestIfResultIsEmpty() {
    final List<Message> messages = Collections.emptyList();
    Mockito.when(this.channel.getMessages()).thenReturn(messages);
    assertThat(this.monitor.add(this.listener)).isTrue();
    Mockito.verify(this.channel).getQueueUuid();
    Mockito.verify(this.listener).getQueueUuid();
    Mockito.verify(this.executor).execute(this.monitor);

    this.monitor.run();

    Mockito.verify(this.channel).getMessages();
    Mockito.verifyNoMoreInteractions(this.listener);
    Mockito.verify(this.executor, Mockito.times(2)).execute(this.monitor);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testHandleReceiveAddEndpoint() throws Exception {
    final Map<Address, Optional<RemoteRpcEndpoint>> endpoints = ImmutableMap.of(
            endpointAddress, Optional.of(firstEndpoint));
    testActorRef.tell(new UpdateRemoteEndpoints(endpoints), ActorRef.noSender());

    Mockito.verify(service).registerRpcImplementation(
            Mockito.any(RemoteRpcImplementation.class), Mockito.eq(firstEndpoint.getRpcs()));
    Mockito.verifyNoMoreInteractions(service, oldReg, newReg);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void shouldNotStopBeforeLastListenerRemoved() {
    this.monitor.add(this.listener);
    this.monitor.add(this.listener);
    Mockito.verify(this.executor).execute(this.monitor);

    final boolean result = this.monitor.remove(this.listener);

    assertThat(result).isFalse();
    Mockito.verifyNoMoreInteractions(this.executor);
    assertThat(this.monitor.isShutDown()).isFalse();
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test public void testFakeScheduledExecutorService_taskScheduleAnotherTask() {
  Runnable runnable = mock(Runnable.class);
  Runnable scheduled = () -> executor.schedule(runnable, 3, TimeUnit.MILLISECONDS);
  executor.schedule(scheduled, 2, TimeUnit.MILLISECONDS);
  elapse(Duration.ofMillis(2));
  elapse(Duration.ofMillis(3));
  verify(runnable).run();
  Mockito.verifyNoMoreInteractions(runnable);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void deleteMessageFromFactoryWhenS3FactoryExists() {
    AmazonSQSClient sqs = Mockito.mock(AmazonSQSClient.class);
    AmazonS3Client s3 = Mockito.mock(AmazonS3Client.class);
    String s3Id = "123";
    SqsMessage m = new SqsMessage(RECEIPT_HANDLE, new byte[] {}, 1000, Optional.of(s3Id),
            new SqsMessage.Service(Optional.of(() -> s3), () -> sqs, Optional.of(s3), sqs,
                    QUEUE, Optional.of(BUCKET)));
    Mockito.when(sqs.deleteMessage(QUEUE, RECEIPT_HANDLE))
            .thenReturn(new DeleteMessageResult());
    m.deleteMessage(Client.FROM_FACTORY);
    InOrder inorder = Mockito.inOrder(sqs, s3);
    inorder.verify(s3, Mockito.times(1)).deleteObject(BUCKET, s3Id);
    inorder.verify(sqs, Mockito.times(1)).deleteMessage(QUEUE, RECEIPT_HANDLE);
    inorder.verify(s3, Mockito.times(1)).shutdown();
    inorder.verify(sqs, Mockito.times(1)).shutdown();
    Mockito.verifyNoMoreInteractions(sqs, s3);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@GwtIncompatible // Mockito
public void testOnSuccessThrowsRuntimeException() throws Exception {
  RuntimeException exception = new RuntimeException();
  String result = "result";
  SettableFuture<String> future = SettableFuture.create();
  @SuppressWarnings("unchecked") // Safe for a mock
  FutureCallback<String> callback = Mockito.mock(FutureCallback.class);
  addCallback(future, callback, directExecutor());
  Mockito.doThrow(exception).when(callback).onSuccess(result);
  future.set(result);
  assertEquals(result, future.get());
  Mockito.verify(callback).onSuccess(result);
  Mockito.verifyNoMoreInteractions(callback);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void shouldStopIfLastListenerRemoved() {
    this.monitor.add(this.listener);
    this.monitor.add(this.listener);
    this.monitor.remove(this.listener);
    Mockito.verify(this.executor).execute(this.monitor);

    final boolean result = this.monitor.remove(this.listener);

    assertThat(result).isTrue();
    Mockito.verifyNoMoreInteractions(this.executor);
    assertThat(this.monitor.isShutDown()).isTrue();
}