Java 类org.mockito.InOrder 实例源码

@Test
public void testTimeoutSelectorSubsequentThrows() {
    PublishSubject<Integer> source = PublishSubject.create();
    final PublishSubject<Integer> timeout = PublishSubject.create();

    Function<Integer, Observable<Integer>> timeoutFunc = new Function<Integer, Observable<Integer>>() {
        @Override
        public Observable<Integer> apply(Integer t1) {
            throw new TestException();
        }
    };

    Observable<Integer> other = Observable.fromIterable(Arrays.asList(100));

    Observer<Object> o = TestHelper.mockObserver();
    InOrder inOrder = inOrder(o);

    source.timeout(timeout, timeoutFunc, other).subscribe(o);

    source.onNext(1);

    inOrder.verify(o).onNext(1);
    inOrder.verify(o).onError(any(TestException.class));
    verify(o, never()).onComplete();

}

@Test
public void shouldSynchronizeAllConfigurationsForPolicy_whenFullPolicyConfiguration() {
    // given
    testee.setPolicyConfigurations(ImmutableList.of(policyConfigurationMock));

    // when
    testee.sync();

    // then
    InOrder order = inOrder(applicationConfiguratorMock,
            policyConfiguratorMock,
            conditionConfiguratorMock,
            externalServiceConditionConfiguratorMock,
            nrqlConditionConfiguratorMock,
            channelConfiguratorMock);
    order.verify(policyConfiguratorMock).sync(policyConfigurationMock);
    order.verify(conditionConfiguratorMock).sync(policyConfigurationMock);
    order.verify(externalServiceConditionConfiguratorMock).sync(policyConfigurationMock);
    order.verify(nrqlConditionConfiguratorMock).sync(policyConfigurationMock);
    order.verify(channelConfiguratorMock).sync(policyConfigurationMock);
    order.verifyNoMoreInteractions();
}

@Test
public void timestampWithScheduler() {
    TestScheduler scheduler = new TestScheduler();

    PublishSubject<Integer> source = PublishSubject.create();
    Observable<Timed<Integer>> m = source.timestamp(scheduler);
    m.subscribe(observer);

    source.onNext(1);
    scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
    source.onNext(2);
    scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
    source.onNext(3);

    InOrder inOrder = inOrder(observer);

    inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(1, 0, TimeUnit.MILLISECONDS));
    inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(2, 100, TimeUnit.MILLISECONDS));
    inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(3, 200, TimeUnit.MILLISECONDS));

    verify(observer, never()).onError(any(Throwable.class));
    verify(observer, never()).onComplete();
}

@Test
public void shouldNotRemoveUnusedUserChannel() {
    // given
    AlertsChannel userChannelInPolicy = channelInPolicy(savedUserChannel, POLICY_ID);
    when(alertsChannelsApiMock.list()).thenReturn(ImmutableList.of(userChannelInPolicy));
    when(alertsChannelsApiMock.deleteFromPolicy(POLICY_ID, userChannelInPolicy.getId()))
            .thenReturn(userChannelInPolicy);

    // when
    PolicyConfiguration policyConfiguration = buildPolicyConfiguration();
    testee.sync(policyConfiguration);

    // then
    AlertsPolicyChannels expected = AlertsPolicyChannels.builder()
            .policyId(POLICY_ID)
            .channelIds(emptySet())
            .build();

    InOrder order = inOrder(alertsChannelsApiMock, alertsPoliciesApiMock);
    order.verify(alertsChannelsApiMock).list();
    order.verify(alertsPoliciesApiMock).updateChannels(expected);
    order.verify(alertsChannelsApiMock).deleteFromPolicy(POLICY_ID, savedUserChannel.getId());
    order.verify(alertsChannelsApiMock, never()).delete(savedUserChannel.getId());
    order.verifyNoMoreInteractions();
}

@Test
public void onTouchEvent_TOUCH_START_canSwypeTest() {
    // when
    when(touchEvent.getType()).thenReturn(TouchTypes.TOUCH_START);

    // when(multiPageController.isAnimationRunning()).thenReturn(true);
    NativeEvent nativeEvent = mock(NativeEvent.class);
    when(touchEvent.getNativeEvent()).thenReturn(nativeEvent);
    when(touchController.canSwype(multiPageController)).thenReturn(false);
    // given
    testObj.onTouchEvent(touchEvent);

    // then
    InOrder inOrder = inOrder(userAgentUtil, touchEventReader, touchController, touchEndTimerFactory, touchEndTimer, touchEvent, multiPageController);

    inOrder.verify(touchEvent).getType();
    inOrder.verify(touchEvent).getNativeEvent();
    inOrder.verify(touchController).canSwype(multiPageController);
}

@Test
public void testFirstOrDefaultWithPredicateFlowable() {
    Flowable<Integer> observable = Flowable.just(1, 2, 3, 4, 5, 6)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer t1) {
                    return t1 % 2 == 0;
                }
            })
            .first(8);

    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);

    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(2);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
}

@Test
public void shouldNotSynchronizeAnything_whenNoConfigurationsSet() {
    // given

    // when
    testee.sync();

    // then
    InOrder order = inOrder(applicationConfiguratorMock,
            policyConfiguratorMock,
            conditionConfiguratorMock,
            externalServiceConditionConfiguratorMock,
            nrqlConditionConfiguratorMock,
            channelConfiguratorMock);
    order.verifyNoMoreInteractions();
}

@Test
public void testOnMessageSuccessful() throws IOException {
  InputStream mis = mock(InputStream.class, withSettings().extraInterfaces(Seekable.class, PositionedReadable.class));
  doReturn(42).when(mis).read(any(byte[].class), anyInt(), anyInt());

  FSDataInputStream fdis = new FSDataInputStream(mis);
  Response response = getResponse(7L, 4096, fdis);

  InOrder inOrder = Mockito.inOrder(mis);

  inOrder.verify((Seekable) mis).seek(7);
  inOrder.verify(mis).read(any(byte[].class), anyInt(), anyInt());

  assertEquals(42, ((DFS.GetFileDataResponse) response.pBody).getRead());
  assertEquals(42, response.dBodies[0].readableBytes());
}

@Test
public void concatVeryLongObservableOfObservablesTakeHalf() {
    final int n = 10000;
    Flowable<Flowable<Integer>> source = Flowable.range(0, n).map(new Function<Integer, Flowable<Integer>>() {
        @Override
        public Flowable<Integer> apply(Integer v) {
            return Flowable.just(v);
        }
    });

    Flowable<List<Integer>> result = Flowable.concat(source).take(n / 2).toList();

    Subscriber<List<Integer>> o = TestHelper.mockSubscriber();
    InOrder inOrder = inOrder(o);

    result.subscribe(o);

    List<Integer> list = new ArrayList<Integer>(n);
    for (int i = 0; i < n / 2; i++) {
        list.add(i);
    }
    inOrder.verify(o).onNext(list);
    verify(o, never()).onError(any(Throwable.class));
}

@Test
public void testFirstOrDefaultWithPredicateAndEmpty() {
    Single<Integer> observable = first(Flowable.just(1)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer t1) {
                    return t1 % 2 == 0;
                }
            })
            , 2);

    observable.subscribe(wo);

    InOrder inOrder = inOrder(wo);
    inOrder.verify(wo, times(1)).onSuccess(2);
    inOrder.verifyNoMoreInteractions();
}

@Test
public void shouldCreateGatewaySenderAfterRegions() {
  CacheCreation cacheCreation = new CacheCreation();
  GatewayReceiver receiver = mock(GatewayReceiver.class);
  cacheCreation.addGatewayReceiver(receiver);
  cacheCreation.addRootRegion(new RegionCreation(cacheCreation, "region"));
  GemFireCacheImpl cache = mock(GemFireCacheImpl.class);
  GatewayReceiverFactory receiverFactory = mock(GatewayReceiverFactory.class);
  when(cache.createGatewayReceiverFactory()).thenReturn(receiverFactory);
  when(receiverFactory.create()).thenReturn(receiver);

  InOrder inOrder = inOrder(cache, receiverFactory);
  cacheCreation.create(cache);

  inOrder.verify(cache).basicCreateRegion(eq("region"), any());
  inOrder.verify(cache).createGatewayReceiverFactory();
  inOrder.verify(receiverFactory).create();
}

@Test
public void testDelayWithFlowableSingleSend1() {
    PublishProcessor<Integer> source = PublishProcessor.create();
    final PublishProcessor<Integer> delay = PublishProcessor.create();

    Function<Integer, Flowable<Integer>> delayFunc = new Function<Integer, Flowable<Integer>>() {

        @Override
        public Flowable<Integer> apply(Integer t1) {
            return delay;
        }
    };
    Subscriber<Object> o = TestHelper.mockSubscriber();
    InOrder inOrder = inOrder(o);

    source.delay(delayFunc).subscribe(o);

    source.onNext(1);
    delay.onNext(1);
    delay.onNext(2);

    inOrder.verify(o).onNext(1);
    inOrder.verifyNoMoreInteractions();
    verify(o, never()).onError(any(Throwable.class));
}

@Test
public void testNotifyDiscovering() throws Exception {
    AdapterListener adapterListener1 = mock(AdapterListener.class);
    AdapterListener adapterListener2 = mock(AdapterListener.class);
    governor.addAdapterListener(adapterListener1);
    governor.addAdapterListener(adapterListener2);

    governor.notifyDiscovering(true);

    InOrder inOrder = inOrder(adapterListener1, adapterListener2);

    inOrder.verify(adapterListener1, times(1)).discovering(true);
    inOrder.verify(adapterListener2, times(1)).discovering(true);

    // this should be ignored by governor, a log message must be issued
    doThrow(Exception.class).when(adapterListener1).discovering(anyBoolean());

    governor.notifyDiscovering(true);
    inOrder.verify(adapterListener1, times(1)).discovering(true);
    inOrder.verify(adapterListener2, times(1)).discovering(true);
    inOrder.verifyNoMoreInteractions();
}

@Test
public void stopsProcessingOnExceptionAndThrowsExceptionWithRightCause() throws Exception {
    // Given
    final Exception expected = new ExecutionException("Test ExecutionException", new BogusTestException());
    InOrder inOrder = inOrder(mockFuture1, mockFuture2, mockRunnable);
    doThrow(expected).when(mockFuture1).get();

    // When
    try {
        subject.run();
        fail("Should have thrown an Exception");
    } catch (Exception e) {
        // Then
        assertThat(e.getCause(), is(instanceOf(ExecutionException.class)));
        assertThat((ExecutionException)e.getCause(), is(sameInstance(expected)));
        inOrder.verify(mockFuture1, times(1)).get();
        inOrder.verify(mockFuture2, times(0)).get();
        inOrder.verify(mockRunnable, times(0)).run();
        inOrder.verifyNoMoreInteractions();
    }
}

@Test
public void testSetsDelayOnEncoderAfterAddingFrame() {
  when(gifEncoder.start(any(OutputStream.class))).thenReturn(true);
  when(gifEncoder.addFrame(any(Bitmap.class))).thenReturn(true);

  when(decoder.getFrameCount()).thenReturn(1);
  when(decoder.getNextFrame()).thenReturn(Bitmap.createBitmap(100, 100, Bitmap.Config.RGB_565));
  int expectedIndex = 34;
  when(decoder.getCurrentFrameIndex()).thenReturn(expectedIndex);
  int expectedDelay = 5000;
  when(decoder.getDelay(eq(expectedIndex))).thenReturn(expectedDelay);

  encoder.encode(resource, file, options);

  InOrder order = inOrder(gifEncoder, decoder);
  order.verify(decoder).advance();
  order.verify(gifEncoder).addFrame(any(Bitmap.class));
  order.verify(gifEncoder).setDelay(eq(expectedDelay));
  order.verify(decoder).advance();
}

@Test
public void testZipIterableSameSize() {
    PublishProcessor<String> r1 = PublishProcessor.create();
    /* define a Subscriber to receive aggregated events */
    Subscriber<String> o = TestHelper.mockSubscriber();
    InOrder io = inOrder(o);

    Iterable<String> r2 = Arrays.asList("1", "2", "3");

    r1.zipWith(r2, zipr2).subscribe(o);

    r1.onNext("one-");
    r1.onNext("two-");
    r1.onNext("three-");
    r1.onComplete();

    io.verify(o).onNext("one-1");
    io.verify(o).onNext("two-2");
    io.verify(o).onNext("three-3");
    io.verify(o).onComplete();

    verify(o, never()).onError(any(Throwable.class));

}

@Test
public void sampleWithSamplerEmptySource() {
    PublishSubject<Integer> source = PublishSubject.create();
    PublishSubject<Integer> sampler = PublishSubject.create();

    Observable<Integer> m = source.sample(sampler);
    m.subscribe(observer2);

    source.onComplete();
    sampler.onNext(1);

    InOrder inOrder = inOrder(observer2);
    inOrder.verify(observer2, times(1)).onComplete();
    verify(observer2, never()).onNext(any());
    verify(observer, never()).onError(any(Throwable.class));
}

@Test
public void testRangeWithScheduler() {
    TestScheduler scheduler = new TestScheduler();
    Flowable<Integer> observable = Flowable.range(3, 4).subscribeOn(scheduler);

    Subscriber<Integer> observer = TestHelper.mockSubscriber();

    observable.subscribe(observer);

    scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);

    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(3);
    inOrder.verify(observer, times(1)).onNext(4);
    inOrder.verify(observer, times(1)).onNext(5);
    inOrder.verify(observer, times(1)).onNext(6);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
}

@Test
public void testSingleOrDefaultWithPredicateAndTooManyElementsFlowable() {
    Flowable<Integer> observable = Flowable.just(1, 2, 3, 4)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer t1) {
                    return t1 % 2 == 0;
                }
            })
            .single(6);

    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);

    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onError(
            isA(IllegalArgumentException.class));
    inOrder.verifyNoMoreInteractions();
}

@Test
public void should_start_with_when_given_a_non_void_method() {
    // GIVEN
    SystemUnderTest sut = mock(SystemUnderTest.class);
    when(sut.nonVoidMethod()).thenReturn("expected result");
    GivenWhenThenDefinition gwtMock = mock(GivenWhenThenDefinition.class);

    // WHEN
    when(sut::nonVoidMethod).then(result -> {
        assertThat(result).isEqualTo("expected result");
        gwtMock.thenTheActualResultIsInKeepingWithTheExpectedResult();
    });

    // THEN
    InOrder inOrder = Mockito.inOrder(sut, gwtMock);
    inOrder
            .verify(sut)
            .nonVoidMethod();
    inOrder
            .verify(gwtMock)
            .thenTheActualResultIsInKeepingWithTheExpectedResult();
    inOrder.verifyNoMoreInteractions();
}

@Test
public void testFirstWithPredicateAndEmptyObservable() {
    Observable<Integer> o = Observable.just(1)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer t1) {
                    return t1 % 2 == 0;
                }
            })
            .firstElement().toObservable();

    Observer<Integer> observer = TestHelper.mockObserver();
    o.subscribe(observer);

    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer).onComplete();
    inOrder.verify(observer, never()).onError(any(Throwable.class));
    inOrder.verifyNoMoreInteractions();
}

@Test
public void testFirstWithPredicateAndOneElement() {
    Maybe<Integer> observable = firstElement(Flowable.just(1, 2)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer t1) {
                    return t1 % 2 == 0;
                }
            })
            );

    observable.subscribe(wm);

    InOrder inOrder = inOrder(wm);
    inOrder.verify(wm, times(1)).onSuccess(2);
    inOrder.verifyNoMoreInteractions();
}

@Test
public void testFirstWithPredicateAndOneElement() {
    Maybe<Integer> o = Observable.just(1, 2)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer t1) {
                    return t1 % 2 == 0;
                }
            })
            .firstElement();

    o.subscribe(wm);

    InOrder inOrder = inOrder(wm);
    inOrder.verify(wm, times(1)).onSuccess(2);
    inOrder.verifyNoMoreInteractions();
}

@Test
public void testStartWithWithScheduler() {
    TestScheduler scheduler = new TestScheduler();
    Flowable<Integer> observable = Flowable.just(3, 4).startWith(Arrays.asList(1, 2)).subscribeOn(scheduler);

    Subscriber<Integer> observer = TestHelper.mockSubscriber();

    observable.subscribe(observer);

    scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);

    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(1);
    inOrder.verify(observer, times(1)).onNext(2);
    inOrder.verify(observer, times(1)).onNext(3);
    inOrder.verify(observer, times(1)).onNext(4);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
}

@Test
    public void testLastWithPredicate() {
        Maybe<Integer> observable = lastElement(Flowable.just(1, 2, 3, 4, 5, 6)
                .filter(new Predicate<Integer>() {

                    @Override
                    public boolean test(Integer t1) {
                        return t1 % 2 == 0;
                    }
                })
                );

        MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
        observable.subscribe(observer);

        InOrder inOrder = inOrder(observer);
        inOrder.verify(observer, times(1)).onSuccess(6);
//        inOrder.verify(observer, times(1)).onComplete();
        inOrder.verifyNoMoreInteractions();
    }

@Test
public void testFirstWithPredicateAndEmpty() {
    Maybe<Integer> o = Observable.just(1)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer t1) {
                    return t1 % 2 == 0;
                }
            })
            .firstElement();

    o.subscribe(wm);

    InOrder inOrder = inOrder(wm);
    inOrder.verify(wm, times(1)).onComplete();
    inOrder.verify(wm, never()).onError(any(Throwable.class));
    inOrder.verifyNoMoreInteractions();
}

@Test
public void timestampWithScheduler2() {
    TestScheduler scheduler = new TestScheduler();

    PublishProcessor<Integer> source = PublishProcessor.create();
    Flowable<Timed<Integer>> m = source.timestamp(scheduler);
    m.subscribe(observer);

    source.onNext(1);
    source.onNext(2);
    scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
    scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
    source.onNext(3);

    InOrder inOrder = inOrder(observer);

    inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(1, 0, TimeUnit.MILLISECONDS));
    inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(2, 0, TimeUnit.MILLISECONDS));
    inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(3, 200, TimeUnit.MILLISECONDS));

    verify(observer, never()).onError(any(Throwable.class));
    verify(observer, never()).onComplete();
}

@Test
public void testZipIterableSecondShorter() {
    PublishProcessor<String> r1 = PublishProcessor.create();
    /* define a Subscriber to receive aggregated events */
    Subscriber<String> o = TestHelper.mockSubscriber();
    InOrder io = inOrder(o);

    Iterable<String> r2 = Arrays.asList("1", "2");

    r1.zipWith(r2, zipr2).subscribe(o);

    r1.onNext("one-");
    r1.onNext("two-");
    r1.onNext("three-");
    r1.onComplete();

    io.verify(o).onNext("one-1");
    io.verify(o).onNext("two-2");
    io.verify(o).onComplete();

    verify(o, never()).onError(any(Throwable.class));

}

@Test
public void testRecyclesFrameResourceBeforeWritingIfTransformedResourceIsDifferent() {
  when(decoder.getFrameCount()).thenReturn(1);
  when(frameTransformation.transform(anyContext(), eq(frameResource), anyInt(), anyInt()))
      .thenReturn(transformedResource);
  Bitmap expected = Bitmap.createBitmap(200, 200, Bitmap.Config.ARGB_8888);
  when(transformedResource.get()).thenReturn(expected);

  when(gifEncoder.start(any(OutputStream.class))).thenReturn(true);

  encoder.encode(resource, file, options);

  InOrder order = inOrder(frameResource, gifEncoder);
  order.verify(frameResource).recycle();
  order.verify(gifEncoder).addFrame(eq(expected));
}

@Test
public void testRecyclesFrameResourceAfterWritingIfFrameResourceIsNotTransformed() {
  when(decoder.getFrameCount()).thenReturn(1);
  when(frameTransformation.transform(anyContext(), eq(frameResource), anyInt(), anyInt()))
      .thenReturn(frameResource);
  Bitmap expected = Bitmap.createBitmap(200, 100, Bitmap.Config.ARGB_8888);
  when(frameResource.get()).thenReturn(expected);

  when(gifEncoder.start(any(OutputStream.class))).thenReturn(true);

  encoder.encode(resource, file, options);

  InOrder order = inOrder(frameResource, gifEncoder);
  order.verify(gifEncoder).addFrame(eq(expected));
  order.verify(frameResource).recycle();
}

@Test
public void typical() throws Exception {
  UnpartitionedTableReplication replication = new UnpartitionedTableReplication(DATABASE, TABLE, source, replica,
      copierFactoryManager, eventIdFactory, targetTableLoation, DATABASE, TABLE, copierOptions, listener);
  replication.replicate();

  InOrder replicationOrder = inOrder(copierFactoryManager, copierFactory, copier, sourceLocationManager, replica,
      replicaLocationManager, listener);
  replicationOrder.verify(replica).validateReplicaTable(DATABASE, TABLE);
  replicationOrder.verify(copierFactoryManager).getCopierFactory(sourceTableLocation, replicaTableLocation);
  replicationOrder.verify(copierFactory).newInstance(EVENT_ID, sourceTableLocation, replicaTableLocation,
      copierOptions);
  replicationOrder.verify(listener).copierStart(anyString());
  replicationOrder.verify(copier).copy();
  replicationOrder.verify(listener).copierEnd(any(Metrics.class));
  replicationOrder.verify(sourceLocationManager).cleanUpLocations();
  replicationOrder.verify(replica).updateMetadata(EVENT_ID, sourceTableAndStatistics, DATABASE, TABLE,
      replicaLocationManager);
  replicationOrder.verify(replicaLocationManager).cleanUpLocations();
}

@Test
public void shouldCreateRequiredChannels() {
    // given
    when(alertsChannelsApiMock.list()).thenReturn(ImmutableList.of(savedUserChannel));
    PolicyConfiguration policyConfiguration = buildPolicyConfiguration(EMAIL_CHANNEL, SLACK_CHANNEL);

    // when
    testee.sync(policyConfiguration);

    // then
    AlertsPolicyChannels expected = AlertsPolicyChannels.builder()
            .policyId(POLICY_ID)
            .channelIds(ImmutableSet.of(savedEmailChannel.getId(), savedSlackChannel.getId()))
            .build();

    InOrder order = inOrder(alertsChannelsApiMock, alertsPoliciesApiMock);
    order.verify(alertsChannelsApiMock).list();
    order.verify(alertsChannelsApiMock).create(configuredEmailChannel);
    order.verify(alertsChannelsApiMock).create(configuredSlackChannel);
    order.verify(alertsPoliciesApiMock).updateChannels(expected);
    order.verifyNoMoreInteractions();
}

@Test
public void waitsForDependenciesBeforeCallingDelegateAndReturnProperValue() throws Exception {
    // Given
    final Object expected = new Object(){};
    InOrder inOrder = inOrder(mockFuture1, mockFuture2, mockCallable);
    doReturn(expected).when(mockCallable).call();

    // When
    Object actual = subject.call();

    // Then
    assertThat(actual, is(sameInstance(expected)));
    inOrder.verify(mockFuture1, times(1)).get();
    inOrder.verify(mockFuture2, times(1)).get();
    inOrder.verify(mockCallable, times(1)).call();
    inOrder.verifyNoMoreInteractions();
}

private void assertSentAs7Bit(MessageContent content) throws InterruptedException, ExecutionException {
  CompletableFuture<SmtpClientResponse> future = session.send(ALICE, BOB, content);

  InOrder order = inOrder(channel);
  order.verify(channel).write(req(SmtpCommand.MAIL, "FROM:<" + ALICE + ">"));
  order.verify(channel).write(req(SmtpCommand.RCPT, "TO:<" + BOB + ">"));
  order.verify(channel).write(req(SmtpCommand.DATA));

  responseFuture.complete(Lists.newArrayList(OK_RESPONSE, OK_RESPONSE, OK_RESPONSE));

  order.verify(channel).write(content.getDotStuffedContent());
  verify(channel).write(DotCrlfBuffer.get());
  order.verify(channel).flush();

  secondResponseFuture.complete(Lists.newArrayList(OK_RESPONSE));

  assertThat(future.isDone()).isTrue();
  assertThat(future.get().getResponses().size()).isEqualTo(4);
}

@Test
public void testGetBoolean_true() {

    Document document = mock(Document.class);
    Element firstChild = mock(Element.class);
    Element element = mock(Element.class);
    when(document.getDocumentElement()).thenReturn(element);
    when(element.getFirstChild()).thenReturn(firstChild);
    String xmlConntent = "<root><nodeName class=\"nodeName\"/></root>";
    when(xmlParser.parse(xmlConntent)).thenReturn(document);
    Map<String, String> map = new HashMap<String, String>();
    map.put("attribute", "true");
    when(styleSocket.getStyles(firstChild)).thenReturn(map);

    boolean attribute = instance.getBoolean("nodeName", "attribute");

    assertTrue(attribute);

    InOrder inOrder = inOrder(styleSocket, xmlParser);
    inOrder.verify(xmlParser).parse(xmlConntent);
    inOrder.verify(styleSocket).getStyles(firstChild);
}

@Test
public void initModuleTest() {
    // given
    Element documentElement = XMLParser.parse(SourceListJAXBParserMock.XML).getDocumentElement();

    // when
    testObj.initModule(documentElement);

    // then
    InOrder inOrder = inOrder(sourceListModuleStructure, presenter);
    inOrder.verify(sourceListModuleStructure).createFromXml(anyString(), any(YJsonArray.class));
    inOrder.verify(sourceListModuleStructure).getBean();
    inOrder.verify(presenter).setBean(Matchers.any(SourceListBean.class));
    inOrder.verify(presenter).createAndBindUi(inlineBodyGeneratorSocket);

    assertEquals(presenter.asWidget(), testObj.getView());
}

@Test
public void sampleWithSamplerThrows() {
    PublishSubject<Integer> source = PublishSubject.create();
    PublishSubject<Integer> sampler = PublishSubject.create();

    Observable<Integer> m = source.sample(sampler);
    m.subscribe(observer2);

    source.onNext(1);
    sampler.onNext(1);
    sampler.onError(new RuntimeException("Forced failure!"));

    InOrder inOrder = inOrder(observer2);
    inOrder.verify(observer2, times(1)).onNext(1);
    inOrder.verify(observer2, times(1)).onError(any(RuntimeException.class));
    verify(observer, never()).onComplete();
}

@Test
public void testDistinctUntilChangedOfNormalSourceWithKeySelector() {
    Observable<String> src = Observable.just("a", "b", "c", "C", "c", "B", "b", "a", "e");
    src.distinctUntilChanged(TO_UPPER_WITH_EXCEPTION).subscribe(w);

    InOrder inOrder = inOrder(w);
    inOrder.verify(w, times(1)).onNext("a");
    inOrder.verify(w, times(1)).onNext("b");
    inOrder.verify(w, times(1)).onNext("c");
    inOrder.verify(w, times(1)).onNext("B");
    inOrder.verify(w, times(1)).onNext("a");
    inOrder.verify(w, times(1)).onNext("e");
    inOrder.verify(w, times(1)).onComplete();
    inOrder.verify(w, never()).onNext(anyString());
    verify(w, never()).onError(any(Throwable.class));
}

@Test
public void testSingleOrDefaultWithPredicateAndTooManyElements() {
    Single<Integer> o = Observable.just(1, 2, 3, 4)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer t1) {
                    return t1 % 2 == 0;
                }
            })
            .single(6);

    SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
    o.subscribe(observer);

    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onError(
            isA(IllegalArgumentException.class));
    inOrder.verifyNoMoreInteractions();
}

@Test(timeout = 10000)
public void testTimeoutWithRetry() {

    Subscriber<Long> observer = TestHelper.mockSubscriber();

    // Flowable that sends every 100ms (timeout fails instead)
    FlowableRetryTest.SlowFlowable so = new FlowableRetryTest.SlowFlowable(100, 10);
    Flowable<Long> o = Flowable
            .unsafeCreate(so)
            .timeout(80, TimeUnit.MILLISECONDS)
            .retry(retry5);

    FlowableRetryTest.AsyncObserver<Long> async = new FlowableRetryTest.AsyncObserver<Long>(observer);

    o.subscribe(async);

    async.await();

    InOrder inOrder = inOrder(observer);
    // Should fail once
    inOrder.verify(observer, times(1)).onError(any(Throwable.class));
    inOrder.verify(observer, never()).onComplete();

    assertEquals("Start 6 threads, retry 5 then fail on 6", 6, so.efforts.get());
}