Java Mockito.inOrder方法代码示例

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void should_override_default_answer_for_spy_beans() {
	//given
	final MockitoDoubleConfiguration configuration = configurationParser.parseSpyConfiguration(ANY_NAME, AnyTest.withAnswer());

	//when
	configuration.createMockSettings(mockSettings);

	//then
	final InOrder defaultAnswer = Mockito.inOrder(mockSettings);
	defaultAnswer
			.verify(mockSettings)
			.defaultAnswer(argThat(HasDefaultAnswer.hasAnswerOfType(CallsRealMethods.class)));

	defaultAnswer
			.verify(mockSettings)
			.defaultAnswer(argThat(HasDefaultAnswer.hasAnswerOfType(DoesNothing.class)));
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void shouldSetContent() {
    // given
    String itemId = "content";
    SourcelistItemValue item = new SourcelistItemValue(SourcelistItemType.IMAGE, "value", itemId);

    when(sourceListManagerAdapter.getItemById(itemId)).thenReturn(item);

    // when
    presenter.setContent(itemId);

    // then
    InOrder inOrder = Mockito.inOrder(view, model);
    inOrder.verify(view).setItemContent(item, inlineBodyGeneratorSocket);
    inOrder.verify(model).addAnswer(itemId);
}
 

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

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void shouldBuildViewAndInitializeSubModules() throws Exception {
    // given
    InlineBodyGeneratorSocket bodyGenerator = Mockito.mock(InlineBodyGeneratorSocket.class);
    when(socket.getInlineBodyGeneratorSocket()).thenReturn(bodyGenerator);

    List<String> itemsOrder = Lists.newArrayList("item1", "item2");
    when(orderingItemsDao.getItemsOrder()).thenReturn(itemsOrder);

    List<String> responseAnswers = Lists.newArrayList("resp1", "resp2");
    when(itemsResponseOrderController.getResponseAnswersByItemsOrder(itemsOrder)).thenReturn(responseAnswers);

    // when
    testObj.bindView();

    // then
    InOrder inOrder = Mockito.inOrder(interactionView, itemsMarkingController, itemsResponseOrderController, orderInteractionModuleFactory, viewBuilder,
            orderingResetController, showingAnswersController);
    inOrder.verify(viewBuilder).buildView(bean, bodyGenerator);
    inOrder.verify(itemsResponseOrderController).updateResponseWithNewOrder(itemsOrder);
    inOrder.verify(orderingResetController).reset();
    inOrder.verify(interactionView).setChildrenOrder(itemsOrder);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void shouldUpdateitemsorder() {
    // given
    List<String> itemsOrder = Lists.newArrayList("a", "b");

    // when
    testObj.updateItemsOrder(itemsOrder);

    // then
    InOrder inOrder = Mockito.inOrder(orderingItemsDao, interactionView, itemsResponseOrderController, model);
    inOrder.verify(orderingItemsDao).setItemsOrder(itemsOrder);
    inOrder.verify(interactionView).setChildStyles(item1);
    inOrder.verify(interactionView).setChildStyles(item2);
    inOrder.verify(interactionView).setChildrenOrder(itemsOrder);
    inOrder.verify(itemsResponseOrderController).updateResponseWithNewOrder(itemsOrder);
    inOrder.verify(model).onModelChange();
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void canVisitOldestDirsFirst()
{
    File cacheRoot = new File(TempFileProvider.getTempDir(), GUID.generate());
    cacheRoot.deleteOnExit();
    contentCache.setCacheRoot(cacheRoot);
    
    File f1 = tempfile(createDirs("2000/3/30/17/45/31"), "files-are-unsorted.bin");
    File f2 = tempfile(createDirs("2000/3/4/17/45/31"), "another-file.bin");
    File f3 = tempfile(createDirs("2010/12/24/23/59/58"), "a-second-before.bin");
    File f4 = tempfile(createDirs("2010/12/24/23/59/59"), "last-one.bin");
    File f5 = tempfile(createDirs("2000/1/7/2/7/12"), "first-one.bin");
    
    // Check that directories and files are visited in correct order
    FileHandler handler = Mockito.mock(FileHandler.class);
    contentCache.processFiles(handler);
    
    InOrder inOrder = Mockito.inOrder(handler);
    inOrder.verify(handler).handle(f5);
    inOrder.verify(handler).handle(f2);
    inOrder.verify(handler).handle(f1);
    inOrder.verify(handler).handle(f3);
    inOrder.verify(handler).handle(f4);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void shutdownGracefullyPropagatesAwaitInterrupt() throws Exception {
    final Server server = mock(Server.class);
    final long maxWaitTimeInMillis = ThreadLocalRandom.current().nextLong(1, 10000);

    final InterruptedException interruptedException = new InterruptedException();

    when(server.awaitTermination(anyLong(), any())).thenThrow(interruptedException);

    assertThatThrownBy(() -> Servers.shutdownGracefully(server, maxWaitTimeInMillis))
            .isSameAs(interruptedException);

    InOrder inOrder = Mockito.inOrder(server);

    inOrder.verify(server).shutdown();
    inOrder.verify(server).awaitTermination(eq(maxWaitTimeInMillis), eq(TimeUnit.MILLISECONDS));
    inOrder.verify(server).shutdownNow();
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testPresenterLifeCycleIsRespectedOnStart()
{
    final Presenter presenter = Mockito.spy(Presenter.class);
    final ActivityTest activity = Mockito.spy(new ActivityTest());

    activity.onLoadFinished(null, presenter);
    activity.onStart();

    // Verify onViewAttached and onStart are called in right order
    final InOrder inOrder = Mockito.inOrder(presenter);
    inOrder.verify(presenter).onViewAttached(Mockito.eq(activity));
    inOrder.verify(presenter).onStart(Mockito.anyBoolean());
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void test() {
  executor.execute();

  InOrder inOrder = Mockito.inOrder(handler, sensor);

  inOrder.verify(handler).onSensorsPhase(ArgumentMatchers.argThat(new EventMatcher(true)));
  inOrder.verify(sensor).analyse(project, context);
  inOrder.verify(handler).onSensorsPhase(ArgumentMatchers.argThat(new EventMatcher(false)));
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testAddingBundle() throws Exception {
    assertEquals(primaryValue, extensibleBundleTracker.addingBundle(bundle, bundleEvent).get());
    InOrder inOrder = Mockito.inOrder(primaryTracker, additionalTracker);
    inOrder.verify(primaryTracker).addingBundle(bundle, bundleEvent);
    inOrder.verify(additionalTracker).addingBundle(bundle, bundleEvent);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void shouldSetLockedAndUpdateStylesOnView() throws Exception {
    testObj.setLocked(true);

    InOrder inOrder = Mockito.inOrder(item1, item2, interactionView);
    inOrder.verify(item1).setLocked(true);
    inOrder.verify(item2).setLocked(true);
    inOrder.verify(interactionView).setChildStyles(item1);
    inOrder.verify(interactionView).setChildStyles(item2);
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void testPresenterLifeCycleIsRespectedOnStop()
{
    final Presenter presenter = Mockito.spy(Presenter.class);
    final ActivityTest activity = Mockito.spy(new ActivityTest());

    activity.onLoadFinished(null, presenter);
    activity.onStart();
    activity.onStop();

    // Verify onStop and onViewDetached are called in right order
    final InOrder inOrder = Mockito.inOrder(presenter);
    inOrder.verify(presenter).onStop();
    inOrder.verify(presenter).onViewDetached();
}
 

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 testPresenterLifeCycleIsRespectedOnStart()
{
    final Presenter presenter = Mockito.spy(Presenter.class);
    final FragmentTest activity = Mockito.spy(new FragmentTest());

    activity.onLoadFinished(null, presenter);
    activity.onStart();

    // Verify onViewAttached and onStart are called in right order
    final InOrder inOrder = Mockito.inOrder(presenter);
    inOrder.verify(presenter).onViewAttached(Mockito.eq(activity));
    inOrder.verify(presenter).onStart(Mockito.anyBoolean());
}
 

import org.mockito.Mockito; //导入方法依赖的package包/类
@Test
public void reports_ill_during_initial_replay() throws Exception {
    BlockingEventHandler eventProcessing = new BlockingEventHandler();
    store.write(stream, Arrays.asList(newEvent(), newEvent(), newEvent()));
    subscription = subscription(EndToEndTest::deserialize, eventProcessing);
    subscription.start();

    eventually(() -> {
        assertThat(subscription.health().get(), is(ill));
        assertThat(statusComponent().getReport(), is(new Report(OK, "Stale, catching up. No events processed yet. (Stale for PT0S)")));
    });

    eventProcessing.allowProcessing(1);
    eventually(() -> {
        assertThat(statusComponent().getReport(), is(new Report(OK, "Stale, catching up. Currently at version 1. (Stale for PT0S)")));
    });

    clock.bumpSeconds(123);
    eventProcessing.allowProcessing(2);

    eventually(() -> {
        assertThat(subscription.health().get(), is(healthy));
        assertThat(statusComponent().getReport(), is(new Report(OK, "Caught up at version 3. Initial replay took PT2M3S")));
        assertThat(eventSink.events(), Contains.only(StructuredEventMatcher.ofType("InitialReplayCompleted")));
    });

    InOrder inOrder = Mockito.inOrder(listener);
    inOrder.verify(listener, Mockito.atLeastOnce()).staleAtVersion(Mockito.eq(Optional.empty()));
    inOrder.verify(listener, Mockito.atLeastOnce()).caughtUpAt(argThat(inMemoryPosition(3)));
    Mockito.verify(listener, Mockito.never()).terminated(Mockito.any(), Mockito.any());
}