@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()); }