/** * Returns a Completable which delays the emission of the completion event by the given time while * running on the specified scheduler. * <dl> * <dt><b>Scheduler:</b></dt> * <dd>{@code delay} operates on the {@link Scheduler} you specify.</dd> * </dl> * @param delay the delay time * @param unit the delay unit * @param scheduler the scheduler to run the delayed completion on * @return the new Completable instance * @throws NullPointerException if unit or scheduler is null */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) public final Completable delay(long delay, TimeUnit unit, Scheduler scheduler) { return delay(delay, unit, scheduler, false); }
/** * Returns a Completable which delays the emission of the completion event by the given time while * running on the specified scheduler. * <dl> * <dt><b>Scheduler:</b></dt> * <dd>{@code delay} operates on the {@link Scheduler} you specify.</dd> * </dl> * @param delay the delay time * @param unit the delay unit * @param scheduler the scheduler to run the delayed completion on * @return the new Completable instance * @throws NullPointerException if unit or scheduler is null */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.CUSTOM) public final Completable delay(long delay, TimeUnit unit, Scheduler scheduler) { return delay(delay, unit, scheduler, false); }
@Test(expected = NullPointerException.class) public void delaySchedulerNull() { normal.completable.delay(1, TimeUnit.SECONDS, null); }
@Test(expected = NullPointerException.class) public void delayUnitNull() { normal.completable.delay(1, null); }
/** * Returns a Completable which delays the emission of the completion event by the given time. * <dl> * <dt><b>Scheduler:</b></dt> * <dd>{@code delay} does operate by default on the {@code computation} {@link Scheduler}.</dd> * </dl> * @param delay the delay time * @param unit the delay unit * @return the new Completable instance * @throws NullPointerException if unit is null */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public final Completable delay(long delay, TimeUnit unit) { return delay(delay, unit, Schedulers.computation(), false); }
/** * Returns a Completable which delays the emission of the completion event by the given time. * <dl> * <dt><b>Scheduler:</b></dt> * <dd>{@code delay} does operate by default on the {@code computation} {@link Scheduler}.</dd> * </dl> * @param delay the delay time * @param unit the delay unit * @return the new Completable instance * @throws NullPointerException if unit is null */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public final Completable delay(long delay, TimeUnit unit) { return delay(delay, unit, Schedulers.computation(), false); }
@Override public void run() throws Exception { Completable.complete().delay(10, TimeUnit.SECONDS).blockingAwait(); } })
@Override public void run() throws Exception { Completable.complete().delay(10, TimeUnit.SECONDS).blockingGet(); } })
@Test(timeout = 5000) public void subscribeDispose() throws InterruptedException { final AtomicBoolean complete = new AtomicBoolean(); Completable c = normal.completable .delay(200, TimeUnit.MILLISECONDS) .doOnComplete(new Action() { @Override public void run() { complete.set(true); } }); Disposable d = c.subscribe(); Thread.sleep(100); d.dispose(); Thread.sleep(150); Assert.assertFalse("Completed", complete.get()); }
@Test(timeout = 5000) public void delayNormal() throws InterruptedException { Completable c = normal.completable.delay(250, TimeUnit.MILLISECONDS); final AtomicBoolean done = new AtomicBoolean(); final AtomicReference<Throwable> error = new AtomicReference<Throwable>(); c.subscribe(new CompletableObserver() { @Override public void onSubscribe(Disposable d) { } @Override public void onError(Throwable e) { error.set(e); } @Override public void onComplete() { done.set(true); } }); Thread.sleep(100); Assert.assertFalse("Already done", done.get()); int timeout = 10; while (timeout-- > 0 && !done.get()) { Thread.sleep(100); } Assert.assertTrue("Not done", done.get()); Assert.assertNull(error.get()); }
@Test public void testOnErrorCalledOnScheduler() throws Exception { final CountDownLatch latch = new CountDownLatch(1); final AtomicReference<Thread> thread = new AtomicReference<Thread>(); Completable.error(new Exception()) .delay(0, TimeUnit.MILLISECONDS, Schedulers.newThread()) .doOnError(new Consumer<Throwable>() { @Override public void accept(Throwable throwable) throws Exception { thread.set(Thread.currentThread()); latch.countDown(); } }) .onErrorComplete() .subscribe(); latch.await(); assertNotEquals(Thread.currentThread(), thread.get()); }
@Test(timeout = 5000) public void delayErrorToo() throws InterruptedException { Completable c = error.completable.delay(250, TimeUnit.MILLISECONDS, Schedulers.computation(), true); final AtomicBoolean done = new AtomicBoolean(); final AtomicReference<Throwable> error = new AtomicReference<Throwable>(); c.subscribe(new CompletableObserver() { @Override public void onSubscribe(Disposable d) { } @Override public void onError(Throwable e) { error.set(e); } @Override public void onComplete() { done.set(true); } }); Thread.sleep(100); Assert.assertFalse("Already done", done.get()); Assert.assertNull(error.get()); Thread.sleep(200); Assert.assertFalse("Already done", done.get()); Assert.assertTrue(error.get() instanceof TestException); }
@Test(timeout = 5000) public void delayErrorImmediately() throws InterruptedException { final TestScheduler scheduler = new TestScheduler(); final Completable c = error.completable.delay(250, TimeUnit.MILLISECONDS, scheduler); final AtomicBoolean done = new AtomicBoolean(); final AtomicReference<Throwable> error = new AtomicReference<Throwable>(); c.subscribe(new CompletableObserver() { @Override public void onSubscribe(Disposable d) { } @Override public void onError(Throwable e) { error.set(e); } @Override public void onComplete() { done.set(true); } }); scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); Assert.assertTrue(error.get().toString(), error.get() instanceof TestException); Assert.assertFalse("Already done", done.get()); scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS); Assert.assertFalse("Already done", done.get()); }
final CountDownLatch cdl = new CountDownLatch(1); normal.completable.delay(1, TimeUnit.SECONDS) .doOnDispose(new Action() { @Override
@Test(timeout = 5000) public void subscribe() throws InterruptedException { final AtomicBoolean complete = new AtomicBoolean(); Completable c = normal.completable .delay(100, TimeUnit.MILLISECONDS) .doOnComplete(new Action() { @Override public void run() { complete.set(true); } }); Disposable d = c.subscribe(); assertFalse(d.isDisposed()); Thread.sleep(150); Assert.assertTrue("Not completed", complete.get()); assertTrue(d.isDisposed()); }
@Test public void delayCustomScheduler() { Completable.complete() .delay(100, TimeUnit.MILLISECONDS, Schedulers.trampoline()) .test() .assertResult(); }
@Test public void delaySubscriptionCompletable() throws Exception { Single.just(1).delaySubscription(Completable.complete().delay(100, TimeUnit.MILLISECONDS)) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1); }