Examples with NewThreadWorker io.reactivex.internal.schedulers.NewThreadWorker used on opensource projects

Example 1 with NewThreadWorker

use of io.reactivex.internal.schedulers.NewThreadWorker in project RxJava by ReactiveX.

the class NewThreadSchedulerTest method npeRegression.

/**
     * Regression test to ensure there is no NPE when the worker has been disposed.
     * @throws Exception on error
     */
@Test
public void npeRegression() throws Exception {
    Scheduler s = getScheduler();
    NewThreadWorker w = (NewThreadWorker) s.createWorker();
    w.dispose();
    //This method used to throw a NPE when the worker has been disposed and the parent is null
    w.scheduleActual(new Runnable() {

        @Override
        public void run() {
        }
    }, 0, TimeUnit.MILLISECONDS, null);
}

Example 2 with NewThreadWorker

use of io.reactivex.internal.schedulers.NewThreadWorker 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]);
}