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

Example 56 with Worker

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

the class ExecutorSchedulerTest method testCancelledWorkerDoesntRunTasks.

@Test
public void testCancelledWorkerDoesntRunTasks() {
    final AtomicInteger calls = new AtomicInteger();
    Runnable task = new Runnable() {

        @Override
        public void run() {
            calls.getAndIncrement();
        }
    };
    TestExecutor exec = new TestExecutor();
    Scheduler custom = Schedulers.from(exec);
    Worker w = custom.createWorker();
    try {
        w.schedule(task);
        w.schedule(task);
        w.schedule(task);
    } finally {
        w.dispose();
    }
    exec.executeAll();
    assertEquals(0, calls.get());
}

Example 57 with Worker

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

the class ExecutorSchedulerTest method reuseScheduledExecutorAsWorker.

@Test
public void reuseScheduledExecutorAsWorker() throws Exception {
    ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
    Worker s = Schedulers.from(exec).createWorker();
    assertFalse(s.isDisposed());
    try {
        final CountDownLatch cdl = new CountDownLatch(8);
        Runnable r = new Runnable() {

            @Override
            public void run() {
                cdl.countDown();
            }
        };
        s.schedule(r);
        s.schedule(r, 10, TimeUnit.MILLISECONDS);
        Disposable d = s.schedulePeriodically(r, 10, 10, TimeUnit.MILLISECONDS);
        try {
            assertTrue(cdl.await(5, TimeUnit.SECONDS));
        } finally {
            d.dispose();
        }
    } finally {
        s.dispose();
        exec.shutdown();
    }
    assertTrue(s.isDisposed());
}

Example 58 with Worker

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

the class ExecutorSchedulerTest method rejectingExecutorWorker.

@Test
public void rejectingExecutorWorker() {
    ScheduledExecutorService exec = Executors.newSingleThreadScheduledExecutor();
    exec.shutdown();
    List<Throwable> errors = TestHelper.trackPluginErrors();
    try {
        Worker s = Schedulers.from(exec).createWorker();
        assertSame(EmptyDisposable.INSTANCE, s.schedule(Functions.EMPTY_RUNNABLE));
        s = Schedulers.from(exec).createWorker();
        assertSame(EmptyDisposable.INSTANCE, s.schedule(Functions.EMPTY_RUNNABLE, 10, TimeUnit.MILLISECONDS));
        s = Schedulers.from(exec).createWorker();
        assertSame(EmptyDisposable.INSTANCE, s.schedulePeriodically(Functions.EMPTY_RUNNABLE, 10, 10, TimeUnit.MILLISECONDS));
        TestHelper.assertUndeliverable(errors, 0, RejectedExecutionException.class);
        TestHelper.assertUndeliverable(errors, 1, RejectedExecutionException.class);
        TestHelper.assertUndeliverable(errors, 2, RejectedExecutionException.class);
    } finally {
        RxJavaPlugins.reset();
    }
}

Example 59 with Worker

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

the class NewThreadSchedulerTest method shutdownRejects.

// FIXME no longer testable due to internal changes
//    @Test(timeout = 3000)
//    public void testNoSelfInterrupt() throws InterruptedException {
//        Scheduler.Worker worker = Schedulers.newThread().createWorker();
//        try {
//            final CountDownLatch run = new CountDownLatch(1);
//            final CountDownLatch done = new CountDownLatch(1);
//            final AtomicReference<Throwable> exception = new AtomicReference<T>();
//            final AtomicBoolean interruptFlag = new AtomicBoolean();
//
//            ScheduledRunnable sa = (ScheduledRunnable)worker.schedule(new Runnable() {
//                @Override
//                public void run() {
//                    try {
//                        run.await();
//                    } catch (InterruptedException ex) {
//                        exception.set(ex);
//                    }
//                }
//            });
//
//            sa.add(new Disposable() {
//                @Override
//                public void dispose() {
//                    interruptFlag.set(Thread.currentThread().isInterrupted());
//                    done.countDown();
//                }
//            });
//
//            run.countDown();
//
//            done.await();
//
//            Assert.assertEquals(null, exception.get());
//            Assert.assertFalse("Interrupted?!", interruptFlag.get());
//        } finally {
//            worker.dispose();
//        }
//    }
@Test
public void shutdownRejects() {
    final int[] calls = { 0 };
    Runnable r = new Runnable() {

        @Override
        public void run() {
            calls[0]++;
        }
    };
    Scheduler s = getScheduler();
    Worker w = s.createWorker();
    w.dispose();
    assertTrue(w.isDisposed());
    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));
    NewThreadWorker actual = (NewThreadWorker) w;
    CompositeDisposable cd = new CompositeDisposable();
    actual.scheduleActual(r, 1, TimeUnit.SECONDS, cd);
    assertEquals(0, cd.size());
    assertEquals(0, calls[0]);
}

Example 60 with Worker

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

the class SchedulerTest method disposeSelfPeriodic.

@Test
public void disposeSelfPeriodic() {
    final int[] count = { 0 };
    TestScheduler scheduler = new TestScheduler();
    Worker worker = scheduler.createWorker();
    try {
        final SequentialDisposable sd = new SequentialDisposable();
        Disposable d = worker.schedulePeriodically(new Runnable() {

            @Override
            public void run() {
                count[0]++;
                sd.dispose();
            }
        }, 100, 100, TimeUnit.MILLISECONDS);
        sd.set(d);
        assertEquals(0, count[0]);
        assertFalse(d.isDisposed());
        scheduler.advanceTimeBy(400, TimeUnit.MILLISECONDS);
        assertEquals(1, count[0]);
        assertTrue(d.isDisposed());
    } finally {
        worker.dispose();
    }
}