/** * Emit the given values and complete the Subject. * @param <T> the value type * @param p the target subject * @param values the values to emit */ public static <T> void emit(Subject<T> p, T... values) { for (T v : values) { p.onNext(v); } p.onComplete(); }
@Override public boolean hasObservers() { return actual.hasObservers(); }
@Override public void run() { s.onError(ex); } };
@Test public void testPublishSubjectValueEmpty() { PublishSubject<Integer> async = PublishSubject.create(); async.onComplete(); Subject<Integer> serial = async.toSerialized(); assertFalse(serial.hasObservers()); assertTrue(serial.hasComplete()); assertFalse(serial.hasThrowable()); assertNull(serial.getThrowable()); }
@Override public void onComplete() { DisposableHelper.replace(upstream, null); active = false; signaller.onNext(0); }
@Test public void sj1ToSj2Lifecycle() { rx.subjects.PublishSubject<Integer> ps1 = rx.subjects.PublishSubject.create(); io.reactivex.subjects.Subject<Integer> sj2 = toV2Subject(ps1); io.reactivex.observers.TestObserver<Integer> to = sj2.test(); assertTrue(sj2.hasObservers()); assertTrue(ps1.hasObservers()); assertFalse(sj2.hasComplete()); assertFalse(sj2.hasThrowable()); assertNull(sj2.getThrowable()); Disposable d1 = Disposables.empty(); sj2.onSubscribe(d1); assertFalse(d1.isDisposed()); sj2.onNext(1); sj2.onNext(2); sj2.onComplete(); sj2.onComplete(); sj2.onError(new IOException()); sj2.onNext(3); Disposable d2 = Disposables.empty(); sj2.onSubscribe(d2); assertFalse(d1.isDisposed()); assertTrue(d2.isDisposed()); assertFalse(sj2.hasObservers()); assertFalse(ps1.hasObservers()); assertTrue(sj2.hasComplete()); assertFalse(sj2.hasThrowable()); assertNull(sj2.getThrowable()); to.assertResult(1, 2); }
@Test public void normal() { Subject<Integer> s = PublishSubject.<Integer>create().toSerialized(); TestObserver<Integer> to = s.test(); Observable.range(1, 10).subscribe(s); to.assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); assertFalse(s.hasObservers()); s.onNext(11); List<Throwable> errors = TestHelper.trackPluginErrors(); try { s.onError(new TestException()); TestHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaPlugins.reset(); } s.onComplete(); Disposable bs = Disposables.empty(); s.onSubscribe(bs); assertTrue(bs.isDisposed()); }
@Override public void run() { s.onComplete(); } };
@Test public void testTakeWhileOnSubject1() { Subject<Integer> s = PublishSubject.create(); Observable<Integer> take = s.takeWhile(new Predicate<Integer>() { @Override public boolean test(Integer input) { return input < 3; } }); Observer<Integer> observer = TestHelper.mockObserver(); take.subscribe(observer); s.onNext(1); s.onNext(2); s.onNext(3); s.onNext(4); s.onNext(5); s.onComplete(); verify(observer, times(1)).onNext(1); verify(observer, times(1)).onNext(2); verify(observer, never()).onNext(3); verify(observer, never()).onNext(4); verify(observer, never()).onNext(5); verify(observer, never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void countRestartsOnTimeTick() { TestScheduler scheduler = new TestScheduler(); Subject<Integer> ps = PublishSubject.<Integer>create(); TestObserver<Observable<Integer>> to = ps.window(5, TimeUnit.MILLISECONDS, scheduler, 5, true) .test(); // window #1 ps.onNext(1); ps.onNext(2); scheduler.advanceTimeBy(5, TimeUnit.MILLISECONDS); // window #2 ps.onNext(3); ps.onNext(4); ps.onNext(5); ps.onNext(6); to.assertValueCount(2) .assertNoErrors() .assertNotComplete(); } }
@Test public void onNextNull() { Subject<T> p = create(); try { p.onNext(null); fail("No NullPointerException thrown"); } catch (NullPointerException ex) { assertEquals("onNext called with null. Null values are generally not allowed in 2.x operators and sources.", ex.getMessage()); } p.test().assertEmpty().cancel(); }
@Test public void sj1ToSj2Error() { rx.subjects.PublishSubject<Integer> ps1 = rx.subjects.PublishSubject.create(); io.reactivex.subjects.Subject<Integer> sj2 = toV2Subject(ps1); io.reactivex.observers.TestObserver<Integer> to = sj2.test(); assertTrue(sj2.hasObservers()); assertTrue(ps1.hasObservers()); assertFalse(sj2.hasComplete()); assertFalse(sj2.hasThrowable()); assertNull(sj2.getThrowable()); sj2.onError(new IOException()); assertFalse(sj2.hasObservers()); assertFalse(ps1.hasObservers()); assertFalse(sj2.hasComplete()); assertTrue(sj2.hasThrowable()); assertNotNull(sj2.getThrowable()); assertTrue(sj2.getThrowable() instanceof IOException); to.assertFailure(IOException.class); }
@Override protected void subscribeActual(Observer<? super T> observer) { actual.subscribe(observer); }
@Override public Observable<Connectivity> observeNetworkConnectivity(final Context context) { final String service = Context.CONNECTIVITY_SERVICE; final ConnectivityManager manager = (ConnectivityManager) context.getSystemService(service); networkCallback = createNetworkCallback(context); registerIdleReceiver(context); final NetworkRequest request = new NetworkRequest.Builder().addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) .addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED) .build(); manager.registerNetworkCallback(request, networkCallback); return connectivitySubject.toFlowable(BackpressureStrategy.LATEST).doOnCancel(new Action() { @Override public void run() { tryToUnregisterCallback(manager); tryToUnregisterReceiver(context); } }).startWith(Connectivity.create(context)).distinctUntilChanged().toObservable(); }
@Test public void sj1ToSj2NullException() { rx.subjects.PublishSubject<Integer> ps1 = rx.subjects.PublishSubject.create(); io.reactivex.subjects.Subject<Integer> sj2 = toV2Subject(ps1); io.reactivex.observers.TestObserver<Integer> to = sj2.test(); sj2.onError(null); assertFalse(sj2.hasObservers()); assertFalse(ps1.hasObservers()); to.assertFailure(NullPointerException.class); }
@Test public void onErrorNull() { Subject<T> p = create(); try { p.onError(null); fail("No NullPointerException thrown"); } catch (NullPointerException ex) { assertEquals("onError called with null. Null values are generally not allowed in 2.x operators and sources.", ex.getMessage()); } p.test().assertEmpty().cancel(); } }
@Test public void testErrorThrownIssue1685() { Subject<Object> subject = ReplaySubject.create(); Observable.error(new RuntimeException("oops")) .materialize() .delay(1, TimeUnit.SECONDS) .dematerialize(Functions.<Notification<Object>>identity()) .subscribe(subject); subject.subscribe(); subject.materialize().blockingFirst(); System.out.println("Done"); }
@Test public void testPublishSubjectValueRelay() { PublishSubject<Integer> async = PublishSubject.create(); async.onNext(1); async.onComplete(); Subject<Integer> serial = async.toSerialized(); assertFalse(serial.hasObservers()); assertTrue(serial.hasComplete()); assertFalse(serial.hasThrowable()); assertNull(serial.getThrowable()); }
@Override public void run() { s.onNext(1); } };