/** * Creates a fresh PerhapsProcessor instance. * @param <T> the input and output value type * @return the new PerhapsProcessor instance */ public static <T> PerhapsProcessor<T> create() { return new PerhapsProcessor<T>(); }
@Override public void cancel() { super.cancel(); parent.remove(this); }
@Test public void subscribeDispose() { PerhapsProcessor<Integer> sp = PerhapsProcessor.create(); Disposable d = sp.subscribe(); assertTrue(sp.hasSubscribers()); d.dispose(); assertFalse(sp.hasSubscribers()); }
@Test public void timeout() { PerhapsProcessor<Integer> sp = PerhapsProcessor.create(); sp.timeout(10, TimeUnit.MILLISECONDS) .test() .awaitDone(5, TimeUnit.SECONDS) .assertFailure(TimeoutException.class); assertFalse(sp.hasSubscribers()); }
@Test public void takeUnitHot() { PerhapsProcessor<Integer> sp1 = PerhapsProcessor.create(); PerhapsProcessor<Integer> sp2 = PerhapsProcessor.create(); TestSubscriber<Integer> ts = sp1.takeUntil(sp2) .test() .assertEmpty(); assertTrue(sp1.hasSubscribers()); assertTrue(sp2.hasSubscribers()); sp1.onNext(1); sp1.onComplete(); assertFalse(sp1.hasSubscribers()); assertFalse(sp2.hasSubscribers()); ts.assertResult(1); }
@SuppressWarnings("unchecked") @Test public void ambIterable2() { PerhapsProcessor<Integer> sp1 = PerhapsProcessor.create(); PerhapsProcessor<Integer> sp2 = PerhapsProcessor.create(); TestSubscriber<Integer> ts = Perhaps.amb(Arrays.asList(sp1, sp2)) .test(); assertTrue(sp1.hasSubscribers()); assertTrue(sp2.hasSubscribers()); ts.assertEmpty(); sp2.onNext(2); ts.assertResult(2); assertFalse(sp1.hasSubscribers()); assertFalse(sp2.hasSubscribers()); }
@SuppressWarnings("unchecked") @Test public void ambIterable2Error() { PerhapsProcessor<Integer> sp1 = PerhapsProcessor.create(); PerhapsProcessor<Integer> sp2 = PerhapsProcessor.create(); TestSubscriber<Integer> ts = Perhaps.amb(Arrays.asList(sp1, sp2)) .test(); assertTrue(sp1.hasSubscribers()); assertTrue(sp2.hasSubscribers()); ts.assertEmpty(); sp2.onError(new IOException()); ts.assertFailure(IOException.class); assertFalse(sp1.hasSubscribers()); assertFalse(sp2.hasSubscribers()); }
@Test public void ambWith1() { PerhapsProcessor<Integer> sp1 = PerhapsProcessor.create(); PerhapsProcessor<Integer> sp2 = PerhapsProcessor.create(); TestSubscriber<Integer> ts = sp1.ambWith(sp2) .test(); assertTrue(sp1.hasSubscribers()); assertTrue(sp2.hasSubscribers()); ts.assertEmpty(); sp1.onNext(1); ts.assertResult(1); assertFalse(sp1.hasSubscribers()); assertFalse(sp2.hasSubscribers()); }
@Test public void ambWith2Error() { PerhapsProcessor<Integer> sp1 = PerhapsProcessor.create(); PerhapsProcessor<Integer> sp2 = PerhapsProcessor.create(); TestSubscriber<Integer> ts = sp1.ambWith(sp2) .test(); assertTrue(sp1.hasSubscribers()); assertTrue(sp2.hasSubscribers()); ts.assertEmpty(); sp2.onError(new IOException()); ts.assertFailure(IOException.class); assertFalse(sp1.hasSubscribers()); assertFalse(sp2.hasSubscribers()); }
@Test public void delaySubscriptionScheduler() { PerhapsProcessor<Integer> sp = PerhapsProcessor.create(); TestScheduler scheduler = new TestScheduler(); TestSubscriber<Integer> ts = sp.delaySubscription(1, TimeUnit.SECONDS, scheduler) .test(); assertFalse(sp.hasSubscribers()); ts.assertEmpty(); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); assertTrue(sp.hasSubscribers()); sp.onNext(1); ts.assertResult(1); assertFalse(sp.hasSubscribers()); }
@Override protected void subscribeActual(Subscriber<? super T> s) { InnerSubscription<T> inner = new InnerSubscription<T>(s, this); s.onSubscribe(inner); if (add(inner)) { if (inner.isCancelled()) { remove(inner); } } else { Throwable ex = error; if (ex != null) { inner.error(ex); } else { T v = value; if (v != null) { inner.complete(v); } else { s.onComplete(); } } } }
@Test public void hideCancel() { PerhapsProcessor<Object> sp = PerhapsProcessor.create(); TestSubscriber<Object> ts = sp .hide() .test(); assertTrue(sp.hasSubscribers()); ts.cancel(); assertFalse(sp.hasSubscribers()); ts.assertEmpty(); }
@Test public void doOnCancel() { PerhapsProcessor<Integer> sp = PerhapsProcessor.create(); TestSubscriber<Integer> ts = sp.doOnCancel(this) .test() .assertEmpty(); assertEquals(0, count); assertTrue(sp.hasSubscribers()); ts.cancel(); assertFalse(sp.hasSubscribers()); assertEquals(1, count); }
@Test public void timeoutScheduler() { PerhapsProcessor<Integer> sp = PerhapsProcessor.create(); sp.timeout(10, TimeUnit.MILLISECONDS, Schedulers.single()) .test() .awaitDone(5, TimeUnit.SECONDS) .assertFailure(TimeoutException.class); assertFalse(sp.hasSubscribers()); }
@Test public void takeUnitHotSwitch() { PerhapsProcessor<Integer> sp1 = PerhapsProcessor.create(); PerhapsProcessor<Integer> sp2 = PerhapsProcessor.create(); TestSubscriber<Integer> ts = sp1.takeUntil(sp2) .test() .assertEmpty(); assertTrue(sp1.hasSubscribers()); assertTrue(sp2.hasSubscribers()); sp2.onNext(1); assertFalse(sp1.hasSubscribers()); assertFalse(sp2.hasSubscribers()); ts.assertResult(); }
@SuppressWarnings("unchecked") @Test public void ambArray1() { PerhapsProcessor<Integer> sp1 = PerhapsProcessor.create(); PerhapsProcessor<Integer> sp2 = PerhapsProcessor.create(); TestSubscriber<Integer> ts = Perhaps.ambArray(sp1, sp2) .test(); assertTrue(sp1.hasSubscribers()); assertTrue(sp2.hasSubscribers()); ts.assertEmpty(); sp1.onNext(1); ts.assertResult(1); assertFalse(sp1.hasSubscribers()); assertFalse(sp2.hasSubscribers()); }
@SuppressWarnings("unchecked") @Test public void ambArray1Error() { PerhapsProcessor<Integer> sp1 = PerhapsProcessor.create(); PerhapsProcessor<Integer> sp2 = PerhapsProcessor.create(); TestSubscriber<Integer> ts = Perhaps.ambArray(sp1, sp2) .test(); assertTrue(sp1.hasSubscribers()); assertTrue(sp2.hasSubscribers()); ts.assertEmpty(); sp1.onError(new IOException()); ts.assertFailure(IOException.class); assertFalse(sp1.hasSubscribers()); assertFalse(sp2.hasSubscribers()); }
@Test public void ambWith2() { PerhapsProcessor<Integer> sp1 = PerhapsProcessor.create(); PerhapsProcessor<Integer> sp2 = PerhapsProcessor.create(); TestSubscriber<Integer> ts = sp1.ambWith(sp2) .test(); assertTrue(sp1.hasSubscribers()); assertTrue(sp2.hasSubscribers()); ts.assertEmpty(); sp2.onNext(2); ts.assertResult(2); assertFalse(sp1.hasSubscribers()); assertFalse(sp2.hasSubscribers()); }
@Test public void ambWith1Error() { PerhapsProcessor<Integer> sp1 = PerhapsProcessor.create(); PerhapsProcessor<Integer> sp2 = PerhapsProcessor.create(); TestSubscriber<Integer> ts = sp1.ambWith(sp2) .test(); assertTrue(sp1.hasSubscribers()); assertTrue(sp2.hasSubscribers()); ts.assertEmpty(); sp1.onError(new IOException()); ts.assertFailure(IOException.class); assertFalse(sp1.hasSubscribers()); assertFalse(sp2.hasSubscribers()); }
@Test public void delaySubscriptionPublisher() { PerhapsProcessor<Integer> sp = PerhapsProcessor.create(); PublishProcessor<Integer> pp = PublishProcessor.create(); TestSubscriber<Integer> ts = sp.delaySubscription(pp) .test(); assertFalse(sp.hasSubscribers()); assertTrue(pp.hasSubscribers()); ts.assertEmpty(); pp.onNext(1); assertTrue(sp.hasSubscribers()); assertFalse(pp.hasSubscribers()); sp.onNext(1); ts.assertResult(1); assertFalse(sp.hasSubscribers()); }