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

Example 71 with Worker

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

the class TestSubscriberExTest method interruptTerminalEventAwait.

@Test
public void interruptTerminalEventAwait() {
    TestSubscriberEx<Integer> ts = new TestSubscriberEx<>();
    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.await(5, TimeUnit.SECONDS)) {
                fail("Did not interrupt wait!");
            }
        } catch (InterruptedException expected) {
        // expected
        }
    } finally {
        w.dispose();
    }
}

Example 72 with Worker

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

the class ComputationSchedulerTests method cancelledTaskRetention.

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

Example 73 with Worker

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

the class TestSubscriberTest method interruptTerminalEventAwait.

@Test
public void interruptTerminalEventAwait() {
    TestSubscriber<Integer> ts = new TestSubscriber<>();
    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.await(5, TimeUnit.SECONDS)) {
                fail("Did not interrupt wait!");
            }
        } catch (InterruptedException expected) {
        // expected
        }
    } finally {
        w.dispose();
    }
}

Example 74 with Worker

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

the class ExecutorSchedulerTest method cancelledTasksDontRun.

@Test
public void cancelledTasksDontRun() {
    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 {
        Disposable d1 = w.schedule(task);
        Disposable d2 = w.schedule(task);
        Disposable d3 = w.schedule(task);
        d1.dispose();
        d2.dispose();
        d3.dispose();
        exec.executeAll();
        assertEquals(0, calls.get());
    } finally {
        w.dispose();
    }
}

Example 75 with Worker

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

the class NewThreadSchedulerTest method shutdownRejects.

@Test
@SuppressUndeliverable
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(Disposable.disposed(), w.schedule(r));
    assertEquals(Disposable.disposed(), w.schedule(r, 1, TimeUnit.SECONDS));
    assertEquals(Disposable.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]);
}