Examples with Worker io.reactivex.Scheduler.Worker used on opensource projects

Example 11 with Worker

use of io.reactivex.Scheduler.Worker in project RxAndroid by ReactiveX.

the class HandlerSchedulerTest method workerScheduleOnceDisposedDoesNotRun.

@Test
public void workerScheduleOnceDisposedDoesNotRun() {
    Worker worker = scheduler.createWorker();
    CountingRunnable counter = new CountingRunnable();
    Disposable disposable = worker.schedule(counter);
    disposable.dispose();
    runUiThreadTasks();
    assertEquals(0, counter.get());
}

Example 12 with Worker

use of io.reactivex.Scheduler.Worker in project RxAndroid by ReactiveX.

the class HandlerSchedulerTest method workerScheduleOnceInputValidation.

@Test
public void workerScheduleOnceInputValidation() {
    Worker worker = scheduler.createWorker();
    try {
        worker.schedule(null);
        fail();
    } catch (NullPointerException e) {
        assertEquals("run == null", e.getMessage());
    }
    try {
        worker.schedule(null, 1, MINUTES);
        fail();
    } catch (NullPointerException e) {
        assertEquals("run == null", e.getMessage());
    }
    try {
        worker.schedule(new CountingRunnable(), 1, null);
        fail();
    } catch (NullPointerException e) {
        assertEquals("unit == null", e.getMessage());
    }
}

Example 13 with Worker

use of io.reactivex.Scheduler.Worker in project RxJava by ReactiveX.

the class FlowableReplayTest method testIssue2191_SchedulerUnsubscribeOnError.

/**
     * Specifically test interaction with a Scheduler with subscribeOn.
     *
     * @throws Exception functional interfaces declare throws Exception
     */
@SuppressWarnings("unchecked")
@Test
public void testIssue2191_SchedulerUnsubscribeOnError() throws Exception {
    // setup mocks
    Consumer<Integer> sourceNext = mock(Consumer.class);
    Action sourceCompleted = mock(Action.class);
    Consumer<Throwable> sourceError = mock(Consumer.class);
    Action sourceUnsubscribed = mock(Action.class);
    final Scheduler mockScheduler = mock(Scheduler.class);
    final Disposable mockSubscription = mock(Disposable.class);
    Worker spiedWorker = workerSpy(mockSubscription);
    Subscriber<Integer> mockObserverBeforeConnect = TestHelper.mockSubscriber();
    Subscriber<Integer> mockObserverAfterConnect = TestHelper.mockSubscriber();
    when(mockScheduler.createWorker()).thenReturn(spiedWorker);
    // Flowable under test
    Function<Integer, Integer> mockFunc = mock(Function.class);
    IllegalArgumentException illegalArgumentException = new IllegalArgumentException();
    when(mockFunc.apply(1)).thenReturn(1);
    when(mockFunc.apply(2)).thenThrow(illegalArgumentException);
    ConnectableFlowable<Integer> replay = Flowable.just(1, 2, 3).map(mockFunc).doOnNext(sourceNext).doOnCancel(sourceUnsubscribed).doOnComplete(sourceCompleted).doOnError(sourceError).subscribeOn(mockScheduler).replay();
    replay.subscribe(mockObserverBeforeConnect);
    replay.subscribe(mockObserverBeforeConnect);
    replay.connect();
    replay.subscribe(mockObserverAfterConnect);
    replay.subscribe(mockObserverAfterConnect);
    verify(mockObserverBeforeConnect, times(2)).onSubscribe((Subscription) any());
    verify(mockObserverAfterConnect, times(2)).onSubscribe((Subscription) any());
    // verify interactions
    verify(mockScheduler, times(1)).createWorker();
    verify(spiedWorker, times(1)).schedule((Runnable) notNull());
    verify(sourceNext, times(1)).accept(1);
    verify(sourceError, times(1)).accept(illegalArgumentException);
    verifyObserver(mockObserverBeforeConnect, 2, 2, illegalArgumentException);
    verifyObserver(mockObserverAfterConnect, 2, 2, illegalArgumentException);
    // FIXME no longer supported
    //        verify(spiedWorker, times(1)).isUnsubscribed();
    // FIXME publish also calls cancel
    verify(spiedWorker, times(1)).dispose();
    verify(sourceUnsubscribed, never()).run();
    verifyNoMoreInteractions(sourceNext);
    verifyNoMoreInteractions(sourceCompleted);
    verifyNoMoreInteractions(sourceError);
    verifyNoMoreInteractions(sourceUnsubscribed);
    verifyNoMoreInteractions(spiedWorker);
    verifyNoMoreInteractions(mockSubscription);
    verifyNoMoreInteractions(mockScheduler);
    verifyNoMoreInteractions(mockObserverBeforeConnect);
    verifyNoMoreInteractions(mockObserverAfterConnect);
}

Example 14 with Worker

use of io.reactivex.Scheduler.Worker in project RxJava by ReactiveX.

the class SingleSchedulerTest method shutdownRejects.

@Test
public void shutdownRejects() {
    final int[] calls = { 0 };
    Runnable r = new Runnable() {

        @Override
        public void run() {
            calls[0]++;
        }
    };
    Scheduler s = new SingleScheduler();
    s.shutdown();
    assertEquals(Disposables.disposed(), s.scheduleDirect(r));
    assertEquals(Disposables.disposed(), s.scheduleDirect(r, 1, TimeUnit.SECONDS));
    assertEquals(Disposables.disposed(), s.schedulePeriodicallyDirect(r, 1, 1, TimeUnit.SECONDS));
    Worker w = s.createWorker();
    ((ScheduledWorker) w).executor.shutdownNow();
    assertEquals(Disposables.disposed(), w.schedule(r));
    assertEquals(Disposables.disposed(), w.schedule(r, 1, TimeUnit.SECONDS));
    assertEquals(Disposables.disposed(), w.schedulePeriodically(r, 1, 1, TimeUnit.SECONDS));
    assertEquals(0, calls[0]);
    w.dispose();
    assertTrue(w.isDisposed());
}

Example 15 with Worker

use of io.reactivex.Scheduler.Worker in project RxJava by ReactiveX.

the class TrampolineSchedulerInternalTest method reentrantScheduleShutdown2.

@Test
public void reentrantScheduleShutdown2() {
    final Worker w = Schedulers.trampoline().createWorker();
    try {
        final int[] calls = { 0, 0 };
        w.schedule(new Runnable() {

            @Override
            public void run() {
                calls[0]++;
                w.dispose();
                assertSame(EmptyDisposable.INSTANCE, w.schedule(new Runnable() {

                    @Override
                    public void run() {
                        calls[1]++;
                    }
                }, 1, TimeUnit.MILLISECONDS));
            }
        });
        assertEquals(1, calls[0]);
        assertEquals(0, calls[1]);
    } finally {
        w.dispose();
    }
}