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

Example 51 with Worker

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

the class AbstractSchedulerConcurrencyTests method testUnsubscribeRecursiveScheduleFromInside.

@Test
public void testUnsubscribeRecursiveScheduleFromInside() throws InterruptedException {
    final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
    final AtomicInteger counter = new AtomicInteger();
    final Worker inner = getScheduler().createWorker();
    try {
        inner.schedule(new Runnable() {

            @Override
            public void run() {
                inner.schedule(new Runnable() {

                    int i;

                    @Override
                    public void run() {
                        System.out.println("Run: " + i++);
                        if (i == 10) {
                            inner.dispose();
                        }
                        counter.incrementAndGet();
                        inner.schedule(this);
                    }
                });
            }
        });
        unsubscribeLatch.countDown();
        // let time pass to see if the scheduler is still doing work
        Thread.sleep(200);
        assertEquals(10, counter.get());
    } finally {
        inner.dispose();
    }
}

Example 52 with Worker

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

the class TestSubscriberTest method testInterruptTerminalEventAwaitTimed.

@Test
public void testInterruptTerminalEventAwaitTimed() {
    TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
    final Thread t0 = Thread.currentThread();
    Worker w = Schedulers.computation().createWorker();
    try {
        w.schedule(new Runnable() {

            @Override
            public void run() {
                t0.interrupt();
            }
        }, 200, TimeUnit.MILLISECONDS);
        try {
            if (ts.awaitTerminalEvent(5, TimeUnit.SECONDS)) {
                fail("Did not interrupt wait!");
            }
        } catch (RuntimeException ex) {
            if (!(ex.getCause() instanceof InterruptedException)) {
                fail("The cause is not InterruptedException! " + ex.getCause());
            }
        }
    } finally {
        // clear interrupted flag
        Thread.interrupted();
        w.dispose();
    }
}

Example 53 with Worker

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

the class TestSubscriberTest method testInterruptTerminalEventAwaitAndUnsubscribe.

@Test
public void testInterruptTerminalEventAwaitAndUnsubscribe() {
    TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
    final Thread t0 = Thread.currentThread();
    Worker w = Schedulers.computation().createWorker();
    try {
        w.schedule(new Runnable() {

            @Override
            public void run() {
                t0.interrupt();
            }
        }, 200, TimeUnit.MILLISECONDS);
        ts.awaitTerminalEvent(5, TimeUnit.SECONDS);
        ts.dispose();
        if (!ts.isCancelled()) {
            fail("Did not unsubscribe!");
        }
    } finally {
        w.dispose();
    }
}

Example 54 with Worker

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

the class CachedThreadSchedulerTest method shutdownRejects.

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

        @Override
        public void run() {
            calls[0]++;
        }
    };
    IoScheduler s = new IoScheduler();
    s.shutdown();
    s.shutdown();
    s.scheduleDirect(r);
    s.scheduleDirect(r, 1, TimeUnit.SECONDS);
    s.schedulePeriodicallyDirect(r, 1, 1, TimeUnit.SECONDS);
    Worker w = s.createWorker();
    w.dispose();
    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]);
}

Example 55 with Worker

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

the class ComputationSchedulerTests method testCancelledTaskRetention.

@Test(timeout = 60000)
public void testCancelledTaskRetention() throws InterruptedException {
    Worker w = Schedulers.computation().createWorker();
    try {
        ExecutorSchedulerTest.testCancelledRetention(w, false);
    } finally {
        w.dispose();
    }
    w = Schedulers.computation().createWorker();
    try {
        ExecutorSchedulerTest.testCancelledRetention(w, true);
    } finally {
        w.dispose();
    }
}