void _dispose() { cached.dispose(); } }
private Mono<Void> stopScheduler() { return Mono.fromRunnable(() -> { this.scheduler.dispose(); for (int i = 0; i < 20; i++) { if (this.scheduler.isDisposed()) { break; } try { Thread.sleep(100); } catch (Throwable ex) { break; } } }); }
@Override public void dispose() { actual.dispose(); }
@AfterMethod public void tearDown(){ sharedGroup.dispose(); }
@After public void after() { exec.dispose(); }
@Test public void testDispatch() throws Exception { Scheduler service = Schedulers.newSingle(r -> { Thread t = new Thread(r, "dispatcher"); t.setUncaughtExceptionHandler((t1, e) -> exceptionThrown.set(e)); return t; }); service.dispose(); }
void restart(Scheduler s){ Thread t = Mono.fromCallable(Thread::currentThread) .subscribeOn(s) .block(); s.dispose(); s.start(); Thread t2 = Mono.fromCallable(Thread::currentThread) .subscribeOn(s) .block(); assertThat(t).isNotEqualTo(Thread.currentThread()); assertThat(t).isNotEqualTo(t2); }
@Test public void recursiveParallelCall() throws Exception { Scheduler s = Schedulers.newParallel("work", 4); try { Scheduler.Worker w = s.createWorker(); CountDownLatch latch = new CountDownLatch(2); w.schedule(() -> recursiveCall(w, latch, 0)); latch.await(); } finally { s.dispose(); } }
@Test public void schedulerDecoratorEmptyDecorators() { assertThat(Schedulers.DECORATORS).isEmpty(); assertThatCode(() -> Schedulers.newSingle("foo").dispose()) .doesNotThrowAnyException(); }
@Test public void schedulerDecoratorAddsSameIfDifferentKeys() { AtomicInteger tracker = new AtomicInteger(); BiFunction<Scheduler, ScheduledExecutorService, ScheduledExecutorService> decorator = (scheduler, serv) -> { tracker.addAndGet(1); return serv; }; //decorators are cleared after test Schedulers.addExecutorServiceDecorator("k1", decorator); Schedulers.addExecutorServiceDecorator("k2", decorator); Schedulers.addExecutorServiceDecorator("k3", decorator); //trigger the decorators Schedulers.newSingle("foo").dispose(); assertThat(tracker).as("decorator invoked three times").hasValue(3); }
@Test public void rejectedOnNextLeadsToOnError() { Scheduler scheduler = Schedulers.newSingle("rejectedOnNextLeadsToOnError"); scheduler.dispose(); StepVerifier.create(Flux.just(1, 2, 3) .bufferTimeout(4, Duration.ofMillis(500), scheduler)) .expectError(RejectedExecutionException.class) .verify(Duration.ofSeconds(1)); }
@Test public void scanCapacity() { Scheduler scheduler = Schedulers.newSingle(Thread::new); try { assertThat(scheduler) .matches(s -> Scannable.from(s).isScanAvailable(), "isScanAvailable") .satisfies(s -> assertThat(Scannable.from(s).scan(Scannable.Attr.CAPACITY)).isEqualTo(1)); } finally { scheduler.dispose(); } } }
@Test public void scanCapacity() { Scheduler scheduler = Schedulers.newParallel(12, Thread::new); try { assertThat(scheduler) .matches(s -> Scannable.from(s).isScanAvailable(), "isScanAvailable") .satisfies(s -> assertThat(Scannable.from(s).scan(Scannable.Attr.CAPACITY)).isEqualTo(12)); } finally { scheduler.dispose(); } } }
@Test public void discardOnTimerRejected() { Scheduler scheduler = Schedulers.newSingle("discardOnTimerRejected"); StepVerifier.create(Flux.just(1, 2, 3) .doOnNext(n -> scheduler.dispose()) .bufferTimeout(10, Duration.ofMillis(100), scheduler)) .expectErrorSatisfies(e -> assertThat(e).isInstanceOf(RejectedExecutionException.class)) .verifyThenAssertThat() .hasDiscardedExactly(1); }
@Test public void scanCapacity() { Scheduler scheduler = Schedulers.newElastic(2, Thread::new); Scheduler.Worker worker = scheduler.createWorker(); try { assertThat(Scannable.from(scheduler).scan(Scannable.Attr.CAPACITY)).as("scheduler unbounded").isEqualTo(Integer.MAX_VALUE); assertThat(Scannable.from(worker).scan(Scannable.Attr.CAPACITY)).as("worker capacity").isEqualTo(1); } finally { worker.dispose(); scheduler.dispose(); } } }
@Test public void sampleZipTest3() throws Exception { int elements = 1; CountDownLatch latch = new CountDownLatch(elements + 1); EmitterProcessor<SensorData> sensorDataProcessor = EmitterProcessor.create(); Scheduler scheduler = Schedulers.single(); sensorDataProcessor.publishOn(scheduler) .subscribe(d -> latch.countDown(), null, latch::countDown); Flux.zip(Flux.just(new SensorData(2L, 12.0f)), Flux.just(new SensorData(1L, 14.0f)), this::computeMin) .log("zip3") .subscribe(sensorDataProcessor); awaitLatch(null, latch); scheduler.dispose(); }
@Test public void testOverride() throws InterruptedException { TestSchedulers ts = new TestSchedulers(true); Schedulers.setFactory(ts); Assert.assertEquals(ts.single, Schedulers.newSingle("unused")); Assert.assertEquals(ts.elastic, Schedulers.newElastic("unused")); Assert.assertEquals(ts.parallel, Schedulers.newParallel("unused")); Schedulers.resetFactory(); Scheduler s = Schedulers.newSingle("unused"); s.dispose(); Assert.assertNotSame(ts.single, s); }