From 5864478e45514b37b3e3e4b4165655e8e2930413 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Tue, 19 Sep 2017 16:12:01 -0700 Subject: [PATCH 01/13] Make AutoDisposingSubscriber inherit from FlowableSubscriber --- .../uber/autodispose/observers/AutoDisposingSubscriber.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java index 053e3209e..f6bec0cdf 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java @@ -16,6 +16,7 @@ package com.uber.autodispose.observers; +import io.reactivex.FlowableSubscriber; import io.reactivex.disposables.Disposable; import org.reactivestreams.Subscriber; import org.reactivestreams.Subscription; @@ -24,4 +25,4 @@ * A {@link Disposable} {@link Subscriber} that can automatically dispose itself. Interface here * for type safety but enforcement is left to the implementation. */ -public interface AutoDisposingSubscriber extends Subscriber, Subscription, Disposable {} +public interface AutoDisposingSubscriber extends FlowableSubscriber, Subscription, Disposable {} From d3a5db43d281466b7bf343bf0db0d1cb1abfed66 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Mon, 18 Sep 2017 11:51:43 -0700 Subject: [PATCH 02/13] Add api for observer delegate to AutoDisposingObserver --- .../AutoDisposingObserverImpl.java | 4 +++ .../observers/AutoDisposingObserver.java | 8 ++++- .../autodispose/AutoDisposeObserverTest.java | 35 ++++++++++++++++++- 3 files changed, 45 insertions(+), 2 deletions(-) diff --git a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingObserverImpl.java b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingObserverImpl.java index 2cd1eb9eb..031552ad0 100755 --- a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingObserverImpl.java +++ b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingObserverImpl.java @@ -37,6 +37,10 @@ final class AutoDisposingObserverImpl implements AutoDisposingObserver { this.delegate = delegate; } + @Override public Observer delegateObserver() { + return delegate; + } + @Override public void onSubscribe(final Disposable d) { if (AutoDisposeEndConsumerHelper.setOnce(lifecycleDisposable, lifecycle.doOnEvent(new BiConsumer() { diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java index e955e6e11..6dcb267af 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java @@ -23,4 +23,10 @@ * A {@link Disposable} {@link Observer} that can automatically dispose itself. * Interface here for type safety but enforcement is left to the implementation. */ -public interface AutoDisposingObserver extends Observer, Disposable {} +public interface AutoDisposingObserver extends Observer, Disposable { + + /** + * @return {@link Observer} The delegate Observer that is used under the hood for introspection purposes. + */ + Observer delegateObserver(); +} diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java index cdfeff6cc..3ac357ddf 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java @@ -17,19 +17,24 @@ package com.uber.autodispose; import com.uber.autodispose.test.RecordingObserver; +import com.uber.autodispose.observers.AutoDisposingObserver; import io.reactivex.Maybe; import io.reactivex.Observable; import io.reactivex.ObservableEmitter; import io.reactivex.ObservableOnSubscribe; +import io.reactivex.Observer; import io.reactivex.disposables.Disposable; +import io.reactivex.functions.BiFunction; import io.reactivex.functions.Cancellable; import io.reactivex.functions.Consumer; import io.reactivex.functions.Predicate; import io.reactivex.observers.TestObserver; +import io.reactivex.plugins.RxJavaPlugins; import io.reactivex.subjects.BehaviorSubject; import io.reactivex.subjects.MaybeSubject; import io.reactivex.subjects.PublishSubject; import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; import org.junit.After; import org.junit.Test; @@ -37,6 +42,9 @@ public class AutoDisposeObserverTest { + private final AtomicReference atomicObserver = new AtomicReference(); + private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); + private static final RecordingObserver.Logger LOGGER = new RecordingObserver.Logger() { @Override public void log(String message) { System.out.println(AutoDisposeObserverTest.class.getSimpleName() + ": " + message); @@ -154,7 +162,7 @@ public class AutoDisposeObserverTest { lifecycle.onNext(1); source.onNext(2); - assertThat(source.hasObservers()).isTrue(); + assertThat(source.hasObservers()).isTrue();Å assertThat(lifecycle.hasObservers()).isTrue(); assertThat(o.takeNext()).isEqualTo(2); @@ -256,6 +264,31 @@ public class AutoDisposeObserverTest { }); } + @Test public void verifyObserverDelegate() { + try { + RxJavaPlugins.setOnObservableSubscribe(new BiFunction() { + @Override public Observer apply(Observable source, Observer observer) { + if (atomicObserver.get() == null) { + atomicObserver.set(observer); + } else if (atomicAutoDisposingObserver.get() == null) { + atomicAutoDisposingObserver.set(observer); + RxJavaPlugins.setOnObservableSubscribe(null); + } + return observer; + } + }); + Observable.just(1).to(new ObservableScoper(Maybe.never())).subscribe(); + + assertThat(atomicAutoDisposingObserver.get()).isNotNull(); + assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingObserver.class); + assertThat(((AutoDisposingObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); + assertThat(((AutoDisposingObserver)atomicAutoDisposingObserver.get()).delegateObserver()) + .isEqualTo(atomicObserver.get()); + } finally { + RxJavaPlugins.reset(); + } + } + @Test public void verifyCancellation() throws Exception { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java From c8695bb81f5526aaf0041ff84abba786765b9e23 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Mon, 18 Sep 2017 11:52:37 -0700 Subject: [PATCH 03/13] Add api for observer delegate to AutoDisposingCompletableObserver --- .../AutoDisposingCompletableObserverImpl.java | 5 +++ .../AutoDisposingCompletableObserver.java | 9 ++++- .../AutoDisposeCompletableObserverTest.java | 38 +++++++++++++++++++ 3 files changed, 51 insertions(+), 1 deletion(-) diff --git a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingCompletableObserverImpl.java b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingCompletableObserverImpl.java index 45336c8f4..e7579e21a 100755 --- a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingCompletableObserverImpl.java +++ b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingCompletableObserverImpl.java @@ -19,6 +19,7 @@ import com.uber.autodispose.observers.AutoDisposingCompletableObserver; import io.reactivex.CompletableObserver; import io.reactivex.Maybe; +import io.reactivex.Observer; import io.reactivex.disposables.Disposable; import io.reactivex.disposables.Disposables; import io.reactivex.functions.BiConsumer; @@ -37,6 +38,10 @@ final class AutoDisposingCompletableObserverImpl implements AutoDisposingComplet this.delegate = delegate; } + @Override public CompletableObserver delegateObserver() { + return delegate; + } + @Override public void onSubscribe(final Disposable d) { if (AutoDisposeEndConsumerHelper.setOnce(lifecycleDisposable, lifecycle.doOnEvent(new BiConsumer() { diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java index b5442277c..7a0979f12 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java @@ -17,10 +17,17 @@ package com.uber.autodispose.observers; import io.reactivex.CompletableObserver; +import io.reactivex.Observer; import io.reactivex.disposables.Disposable; /** * A {@link Disposable} {@link CompletableObserver} that can automatically dispose itself. * Interface here for type safety but enforcement is left to the implementation. */ -public interface AutoDisposingCompletableObserver extends CompletableObserver, Disposable {} +public interface AutoDisposingCompletableObserver extends CompletableObserver, Disposable { + + /** + * @return {@link Observer} The delegate Observer that is used under the hood for introspection purposes. + */ + CompletableObserver delegateObserver(); +} diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java index fa24eee47..f846ef7c3 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java @@ -17,17 +17,27 @@ package com.uber.autodispose; import com.uber.autodispose.test.RecordingObserver; +import com.uber.autodispose.observers.AutoDisposingCompletableObserver; + import io.reactivex.Completable; import io.reactivex.CompletableEmitter; +import io.reactivex.CompletableObserver; import io.reactivex.CompletableOnSubscribe; +import io.reactivex.Maybe; +import io.reactivex.Observable; +import io.reactivex.Observer; +import io.reactivex.functions.BiFunction; import io.reactivex.functions.Cancellable; import io.reactivex.functions.Consumer; import io.reactivex.functions.Predicate; import io.reactivex.observers.TestObserver; +import io.reactivex.plugins.RxJavaPlugins; import io.reactivex.subjects.BehaviorSubject; import io.reactivex.subjects.CompletableSubject; import io.reactivex.subjects.MaybeSubject; import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; + import org.junit.After; import org.junit.Test; @@ -37,6 +47,9 @@ public class AutoDisposeCompletableObserverTest { + private final AtomicReference atomicObserver = new AtomicReference<>(); + private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); + private static final RecordingObserver.Logger LOGGER = new RecordingObserver.Logger() { @Override public void log(String message) { System.out.println(AutoDisposeCompletableObserverTest.class.getSimpleName() + ": " + message); @@ -275,6 +288,31 @@ public class AutoDisposeCompletableObserverTest { }); } + @Test public void verifyObserverDelegate() { + try { + RxJavaPlugins.setOnCompletableSubscribe(new BiFunction() { + @Override public CompletableObserver apply(Completable source, CompletableObserver observer) { + if (atomicObserver.get() == null) { + atomicObserver.set(observer); + } else if (atomicAutoDisposingObserver.get() == null) { + atomicAutoDisposingObserver.set(observer); + RxJavaPlugins.setOnObservableSubscribe(null); + } + return observer; + } + }); + Completable.complete().to(new CompletableScoper(Maybe.never())).subscribe(); + + assertThat(atomicAutoDisposingObserver.get()).isNotNull(); + assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingCompletableObserver.class); + assertThat(((AutoDisposingCompletableObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); + assertThat(((AutoDisposingCompletableObserver)atomicAutoDisposingObserver.get()).delegateObserver()) + .isEqualTo(atomicObserver.get()); + } finally { + RxJavaPlugins.reset(); + } + } + @Test public void verifyCancellation() throws Exception { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java From 1244851ff8b95321c369340e16c179ce39f3d0c7 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Mon, 18 Sep 2017 11:53:21 -0700 Subject: [PATCH 04/13] Add api for observer delegate to AutoDisposingMaybeObserver --- .../AutoDisposingMaybeObserverImpl.java | 5 +++ .../observers/AutoDisposingMaybeObserver.java | 9 ++++- .../AutoDisposeMaybeObserverTest.java | 39 +++++++++++++++++++ 3 files changed, 52 insertions(+), 1 deletion(-) diff --git a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingMaybeObserverImpl.java b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingMaybeObserverImpl.java index de1c2b4ae..79c9a8ed5 100755 --- a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingMaybeObserverImpl.java +++ b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingMaybeObserverImpl.java @@ -19,6 +19,7 @@ import com.uber.autodispose.observers.AutoDisposingMaybeObserver; import io.reactivex.Maybe; import io.reactivex.MaybeObserver; +import io.reactivex.Observer; import io.reactivex.disposables.Disposable; import io.reactivex.disposables.Disposables; import io.reactivex.functions.BiConsumer; @@ -37,6 +38,10 @@ final class AutoDisposingMaybeObserverImpl implements AutoDisposingMaybeObser this.delegate = delegate; } + @Override public MaybeObserver delegateObserver() { + return delegate; + } + @Override public void onSubscribe(final Disposable d) { if (AutoDisposeEndConsumerHelper.setOnce(lifecycleDisposable, lifecycle.doOnEvent(new BiConsumer() { diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java index a94372b98..49875247d 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java @@ -17,10 +17,17 @@ package com.uber.autodispose.observers; import io.reactivex.MaybeObserver; +import io.reactivex.Observer; import io.reactivex.disposables.Disposable; /** * A {@link Disposable} {@link MaybeObserver} that can automatically dispose itself. * Interface here for type safety but enforcement is left to the implementation. */ -public interface AutoDisposingMaybeObserver extends MaybeObserver, Disposable {} +public interface AutoDisposingMaybeObserver extends MaybeObserver, Disposable { + + /** + * @return {@Link Observer} The delegate Observer that is used under the hood for introspection purposes. + */ + MaybeObserver delegateObserver(); +} diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java index f79e2fd8d..f9b3be1b8 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java @@ -17,16 +17,26 @@ package com.uber.autodispose; import com.uber.autodispose.test.RecordingObserver; +import com.uber.autodispose.observers.AutoDisposingMaybeObserver; + +import io.reactivex.CompletableObserver; import io.reactivex.Maybe; import io.reactivex.MaybeEmitter; +import io.reactivex.MaybeObserver; import io.reactivex.MaybeOnSubscribe; +import io.reactivex.Observable; +import io.reactivex.Observer; +import io.reactivex.functions.BiFunction; import io.reactivex.functions.Cancellable; import io.reactivex.functions.Consumer; import io.reactivex.functions.Predicate; import io.reactivex.observers.TestObserver; +import io.reactivex.plugins.RxJavaPlugins; import io.reactivex.subjects.BehaviorSubject; import io.reactivex.subjects.MaybeSubject; import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; + import org.junit.After; import org.junit.Test; @@ -42,6 +52,10 @@ public class AutoDisposeMaybeObserverTest { } }; + private final AtomicReference atomicObserver = new AtomicReference<>(); + private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); + + @After public void resetPlugins() { AutoDisposePlugins.reset(); } @@ -321,6 +335,31 @@ public class AutoDisposeMaybeObserverTest { }); } + @Test public void verifyObserverDelegate() { + try { + RxJavaPlugins.setOnMaybeSubscribe(new BiFunction() { + @Override public MaybeObserver apply(Maybe source, MaybeObserver observer) { + if (atomicObserver.get() == null) { + atomicObserver.set(observer); + } else if (atomicAutoDisposingObserver.get() == null) { + atomicAutoDisposingObserver.set(observer); + RxJavaPlugins.setOnObservableSubscribe(null); + } + return observer; + } + }); + Maybe.just(1).to(new MaybeScoper(Maybe.never())).subscribe(); + + assertThat(atomicAutoDisposingObserver.get()).isNotNull(); + assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingMaybeObserver.class); + assertThat(((AutoDisposingMaybeObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); + assertThat(((AutoDisposingMaybeObserver)atomicAutoDisposingObserver.get()).delegateObserver()) + .isEqualTo(atomicObserver.get()); + } finally { + RxJavaPlugins.reset(); + } + } + @Test public void verifyCancellation() throws Exception { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java From 379f47820084d00b95b838f30cae4cde775d85e7 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Mon, 18 Sep 2017 11:55:08 -0700 Subject: [PATCH 05/13] Add api for observer delegate to AutoDisposingSingleObserver --- .../AutoDisposingSingleObserverImpl.java | 5 +++ .../AutoDisposingSingleObserver.java | 10 +++++- .../AutoDisposeSingleObserverTest.java | 35 +++++++++++++++++++ 3 files changed, 49 insertions(+), 1 deletion(-) diff --git a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSingleObserverImpl.java b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSingleObserverImpl.java index 972861462..a32347be4 100755 --- a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSingleObserverImpl.java +++ b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSingleObserverImpl.java @@ -18,6 +18,7 @@ import com.uber.autodispose.observers.AutoDisposingSingleObserver; import io.reactivex.Maybe; +import io.reactivex.Observer; import io.reactivex.SingleObserver; import io.reactivex.disposables.Disposable; import io.reactivex.disposables.Disposables; @@ -37,6 +38,10 @@ final class AutoDisposingSingleObserverImpl implements AutoDisposingSingleObs this.delegate = delegate; } + @Override public SingleObserver delegateObserver() { + return delegate; + } + @Override public void onSubscribe(final Disposable d) { if (AutoDisposeEndConsumerHelper.setOnce(lifecycleDisposable, lifecycle.doOnEvent(new BiConsumer() { diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java index f60553114..3b0b9fc86 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java @@ -16,6 +16,7 @@ package com.uber.autodispose.observers; +import io.reactivex.Observer; import io.reactivex.SingleObserver; import io.reactivex.disposables.Disposable; @@ -23,4 +24,11 @@ * A {@link Disposable} {@link SingleObserver} that can automatically dispose itself. * Interface here for type safety but enforcement is left to the implementation. */ -public interface AutoDisposingSingleObserver extends SingleObserver, Disposable {} +public interface AutoDisposingSingleObserver extends SingleObserver, Disposable { + + /** + * @return {@link SingleObserver} The delegate SingleObserver that is used under the hood for introspection + * purposes. + */ + SingleObserver delegateObserver(); +} diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java index 78a677dab..6b446d742 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java @@ -17,18 +17,25 @@ package com.uber.autodispose; import com.uber.autodispose.test.RecordingObserver; +import com.uber.autodispose.observers.AutoDisposingSingleObserver; + import io.reactivex.Maybe; import io.reactivex.Single; import io.reactivex.SingleEmitter; +import io.reactivex.SingleObserver; import io.reactivex.SingleOnSubscribe; +import io.reactivex.functions.BiFunction; import io.reactivex.functions.Cancellable; import io.reactivex.functions.Consumer; import io.reactivex.functions.Predicate; import io.reactivex.observers.TestObserver; +import io.reactivex.plugins.RxJavaPlugins; import io.reactivex.subjects.BehaviorSubject; import io.reactivex.subjects.MaybeSubject; import io.reactivex.subjects.SingleSubject; import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; + import org.junit.After; import org.junit.Test; @@ -44,6 +51,9 @@ public class AutoDisposeSingleObserverTest { } }; + private final AtomicReference atomicObserver = new AtomicReference<>(); + private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); + @After public void resetPlugins() { AutoDisposePlugins.reset(); } @@ -292,6 +302,31 @@ public class AutoDisposeSingleObserverTest { }); } + @Test public void verifyObserverDelegate() { + try { + RxJavaPlugins.setOnSingleSubscribe(new BiFunction() { + @Override public SingleObserver apply(Single source, SingleObserver observer) { + if (atomicObserver.get() == null) { + atomicObserver.set(observer); + } else if (atomicAutoDisposingObserver.get() == null) { + atomicAutoDisposingObserver.set(observer); + RxJavaPlugins.setOnObservableSubscribe(null); + } + return observer; + } + }); + Single.just(1).to(new SingleScoper(Maybe.never())).subscribe(); + + assertThat(atomicAutoDisposingObserver.get()).isNotNull(); + assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingSingleObserver.class); + assertThat(((AutoDisposingSingleObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); + assertThat(((AutoDisposingSingleObserver)atomicAutoDisposingObserver.get()).delegateObserver()) + .isEqualTo(atomicObserver.get()); + } finally { + RxJavaPlugins.reset(); + } + } + @Test public void verifyCancellation() throws Exception { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java From 675e962394b6859762e13faa4362ed7977988834 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Mon, 18 Sep 2017 11:58:34 -0700 Subject: [PATCH 06/13] Add api for subscriber delegate to AutoDisposingSubscriber --- .../AutoDisposingSubscriberImpl.java | 5 +++ .../observers/AutoDisposingSubscriber.java | 8 +++- .../AutoDisposeSubscriberTest.java | 40 +++++++++++++++++++ 3 files changed, 52 insertions(+), 1 deletion(-) diff --git a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSubscriberImpl.java b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSubscriberImpl.java index 1a0fa60bc..7f5bd43f6 100755 --- a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSubscriberImpl.java +++ b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSubscriberImpl.java @@ -18,6 +18,7 @@ import com.uber.autodispose.observers.AutoDisposingSubscriber; import io.reactivex.Maybe; +import io.reactivex.Observer; import io.reactivex.disposables.Disposable; import io.reactivex.functions.BiConsumer; import io.reactivex.functions.Consumer; @@ -38,6 +39,10 @@ final class AutoDisposingSubscriberImpl implements AutoDisposingSubscriber this.delegate = delegate; } + @Override public Subscriber delegateSubscriber() { + return delegate; + } + @Override public void onSubscribe(final Subscription s) { if (AutoDisposeEndConsumerHelper.setOnce(lifecycleDisposable, lifecycle.doOnEvent(new BiConsumer() { diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java index f6bec0cdf..343767623 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java @@ -25,4 +25,10 @@ * A {@link Disposable} {@link Subscriber} that can automatically dispose itself. Interface here * for type safety but enforcement is left to the implementation. */ -public interface AutoDisposingSubscriber extends FlowableSubscriber, Subscription, Disposable {} +public interface AutoDisposingSubscriber extends FlowableSubscriber, Subscription, Disposable { + + /** + * @return {@link Subscriber} The delegate Subscriber that is used under the hood for introspection purposes. + */ + Subscriber delegateSubscriber(); +} diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java index 45655244e..183ec003b 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java @@ -16,21 +16,31 @@ package com.uber.autodispose; +import com.uber.autodispose.observers.AutoDisposingSubscriber; + import io.reactivex.BackpressureStrategy; import io.reactivex.Flowable; import io.reactivex.FlowableEmitter; import io.reactivex.FlowableOnSubscribe; import io.reactivex.Maybe; +import io.reactivex.MaybeObserver; +import io.reactivex.Single; +import io.reactivex.SingleObserver; import io.reactivex.disposables.Disposable; +import io.reactivex.functions.BiFunction; import io.reactivex.functions.Cancellable; import io.reactivex.functions.Consumer; import io.reactivex.functions.Predicate; +import io.reactivex.plugins.RxJavaPlugins; import io.reactivex.processors.PublishProcessor; import io.reactivex.subjects.BehaviorSubject; import io.reactivex.subjects.MaybeSubject; import io.reactivex.subscribers.TestSubscriber; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; +import org.reactivestreams.Subscriber; + import org.junit.After; import org.junit.Test; @@ -38,6 +48,9 @@ public class AutoDisposeSubscriberTest { + private final AtomicReference atomicSubscriber = new AtomicReference<>(); + private final AtomicReference atomicAutoDisposingSubscriber = new AtomicReference<>(); + @After public void resetPlugins() { AutoDisposePlugins.reset(); } @@ -263,6 +276,33 @@ public class AutoDisposeSubscriberTest { }); } + @Test public void verifySubscriberDelegate() { + try { + RxJavaPlugins.setOnFlowableSubscribe(new BiFunction() { + @Override public Subscriber apply(Flowable source, Subscriber subscriber) { + if (atomicSubscriber.get() == null) { + System.out.println(subscriber.getClass().toString()); + atomicSubscriber.set(subscriber); + } else if (atomicAutoDisposingSubscriber.get() == null) { + System.out.println(subscriber.getClass().toString()); + atomicAutoDisposingSubscriber.set(subscriber); + RxJavaPlugins.setOnFlowableSubscribe(null); + } + return subscriber; + } + }); + Flowable.just(1).to(new FlowableScoper(Maybe.never())).subscribe(); + + assertThat(atomicAutoDisposingSubscriber.get()).isNotNull(); + assertThat(atomicAutoDisposingSubscriber.get()).isInstanceOf(AutoDisposingSubscriber.class); + assertThat(((AutoDisposingSubscriber)atomicAutoDisposingSubscriber.get()).delegateSubscriber()).isNotNull(); + assertThat(((AutoDisposingSubscriber)atomicAutoDisposingSubscriber.get()).delegateSubscriber()) + .isEqualTo(atomicSubscriber.get()); + } finally { + RxJavaPlugins.reset(); + } + } + @Test public void verifyCancellation() throws Exception { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java From 87284548d0c170e2c98fb1f99bb0471d1cd15f48 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Thu, 21 Sep 2017 16:02:19 -0700 Subject: [PATCH 07/13] Fix test styling --- .../autodispose/AutoDisposeCompletableObserverTest.java | 6 +++--- .../java/com/uber/autodispose/AutoDisposeObserverTest.java | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java index f846ef7c3..3ace06dfb 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java @@ -47,15 +47,15 @@ public class AutoDisposeCompletableObserverTest { - private final AtomicReference atomicObserver = new AtomicReference<>(); - private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); - private static final RecordingObserver.Logger LOGGER = new RecordingObserver.Logger() { @Override public void log(String message) { System.out.println(AutoDisposeCompletableObserverTest.class.getSimpleName() + ": " + message); } }; + private final AtomicReference atomicObserver = new AtomicReference<>(); + private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); + @After public void resetPlugins() { AutoDisposePlugins.reset(); } diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java index 3ac357ddf..65aed5b3d 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java @@ -42,15 +42,15 @@ public class AutoDisposeObserverTest { - private final AtomicReference atomicObserver = new AtomicReference(); - private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); - private static final RecordingObserver.Logger LOGGER = new RecordingObserver.Logger() { @Override public void log(String message) { System.out.println(AutoDisposeObserverTest.class.getSimpleName() + ": " + message); } }; + private final AtomicReference atomicObserver = new AtomicReference(); + private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); + @After public void resetPlugins() { AutoDisposePlugins.reset(); } From e3dd21a1f306e06cd0280957cd10308e4dca1134 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Fri, 22 Sep 2017 12:58:00 -0700 Subject: [PATCH 08/13] Fix comments in each interface --- .../observers/AutoDisposingCompletableObserver.java | 2 +- .../uber/autodispose/observers/AutoDisposingMaybeObserver.java | 2 +- .../com/uber/autodispose/observers/AutoDisposingObserver.java | 2 +- .../autodispose/observers/AutoDisposingSingleObserver.java | 3 +-- .../uber/autodispose/observers/AutoDisposingSubscriber.java | 2 +- 5 files changed, 5 insertions(+), 6 deletions(-) diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java index 7a0979f12..e13e4cdcf 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java @@ -27,7 +27,7 @@ public interface AutoDisposingCompletableObserver extends CompletableObserver, Disposable { /** - * @return {@link Observer} The delegate Observer that is used under the hood for introspection purposes. + * @return The delegate {@link CompletableObserver} that is used under the hood for introspection purposes. */ CompletableObserver delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java index 49875247d..951781614 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java @@ -27,7 +27,7 @@ public interface AutoDisposingMaybeObserver extends MaybeObserver, Disposable { /** - * @return {@Link Observer} The delegate Observer that is used under the hood for introspection purposes. + * @return The delegate {@link MayberObserver} that is used under the hood for introspection purposes. */ MaybeObserver delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java index 6dcb267af..5096bc7a7 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java @@ -26,7 +26,7 @@ public interface AutoDisposingObserver extends Observer, Disposable { /** - * @return {@link Observer} The delegate Observer that is used under the hood for introspection purposes. + * @return The delegate {@link Observer} that is used under the hood for introspection purposes. */ Observer delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java index 3b0b9fc86..3b3871f84 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java @@ -27,8 +27,7 @@ public interface AutoDisposingSingleObserver extends SingleObserver, Disposable { /** - * @return {@link SingleObserver} The delegate SingleObserver that is used under the hood for introspection - * purposes. + * @return The delegate {@link SingleObserver} that is used under the hood for introspection purposes. */ SingleObserver delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java index 343767623..df9fb9169 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java @@ -28,7 +28,7 @@ public interface AutoDisposingSubscriber extends FlowableSubscriber, Subscription, Disposable { /** - * @return {@link Subscriber} The delegate Subscriber that is used under the hood for introspection purposes. + * @return The delegate {@link Subscriber} that is used under the hood for introspection purposes. */ Subscriber delegateSubscriber(); } From c78dc63c7f8798aa148b5e89432558e3ee16960e Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Fri, 22 Sep 2017 13:00:03 -0700 Subject: [PATCH 09/13] Remove random character that shouldnt have been added --- .../test/java/com/uber/autodispose/AutoDisposeObserverTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java index 65aed5b3d..37c64e919 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java @@ -162,7 +162,7 @@ public class AutoDisposeObserverTest { lifecycle.onNext(1); source.onNext(2); - assertThat(source.hasObservers()).isTrue();Å + assertThat(source.hasObservers()).isTrue(); assertThat(lifecycle.hasObservers()).isTrue(); assertThat(o.takeNext()).isEqualTo(2); From 45e6c31d452d62dd94dd4e845135ce534faaaf84 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Fri, 22 Sep 2017 13:16:09 -0700 Subject: [PATCH 10/13] Replace isEqualTo asserts with isSameAs, which is technically more correct --- .../uber/autodispose/AutoDisposeCompletableObserverTest.java | 2 +- .../java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java | 2 +- .../test/java/com/uber/autodispose/AutoDisposeObserverTest.java | 2 +- .../com/uber/autodispose/AutoDisposeSingleObserverTest.java | 2 +- .../java/com/uber/autodispose/AutoDisposeSubscriberTest.java | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java index 3ace06dfb..9be043b17 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java @@ -307,7 +307,7 @@ public class AutoDisposeCompletableObserverTest { assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingCompletableObserver.class); assertThat(((AutoDisposingCompletableObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); assertThat(((AutoDisposingCompletableObserver)atomicAutoDisposingObserver.get()).delegateObserver()) - .isEqualTo(atomicObserver.get()); + .isSameAs(atomicObserver.get()); } finally { RxJavaPlugins.reset(); } diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java index f9b3be1b8..9751941fd 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java @@ -354,7 +354,7 @@ public class AutoDisposeMaybeObserverTest { assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingMaybeObserver.class); assertThat(((AutoDisposingMaybeObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); assertThat(((AutoDisposingMaybeObserver)atomicAutoDisposingObserver.get()).delegateObserver()) - .isEqualTo(atomicObserver.get()); + .isSameAs(atomicObserver.get()); } finally { RxJavaPlugins.reset(); } diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java index 37c64e919..b19b7dd79 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java @@ -283,7 +283,7 @@ public class AutoDisposeObserverTest { assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingObserver.class); assertThat(((AutoDisposingObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); assertThat(((AutoDisposingObserver)atomicAutoDisposingObserver.get()).delegateObserver()) - .isEqualTo(atomicObserver.get()); + .isSameAs(atomicObserver.get()); } finally { RxJavaPlugins.reset(); } diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java index 6b446d742..6236000ad 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java @@ -321,7 +321,7 @@ public class AutoDisposeSingleObserverTest { assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingSingleObserver.class); assertThat(((AutoDisposingSingleObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); assertThat(((AutoDisposingSingleObserver)atomicAutoDisposingObserver.get()).delegateObserver()) - .isEqualTo(atomicObserver.get()); + .isSameAs(atomicObserver.get()); } finally { RxJavaPlugins.reset(); } diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java index 183ec003b..f804aac70 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java @@ -297,7 +297,7 @@ public class AutoDisposeSubscriberTest { assertThat(atomicAutoDisposingSubscriber.get()).isInstanceOf(AutoDisposingSubscriber.class); assertThat(((AutoDisposingSubscriber)atomicAutoDisposingSubscriber.get()).delegateSubscriber()).isNotNull(); assertThat(((AutoDisposingSubscriber)atomicAutoDisposingSubscriber.get()).delegateSubscriber()) - .isEqualTo(atomicSubscriber.get()); + .isSameAs(atomicSubscriber.get()); } finally { RxJavaPlugins.reset(); } From 727075803100df67d7feac66f45234610ccb1880 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Fri, 22 Sep 2017 13:36:14 -0700 Subject: [PATCH 11/13] Move test member AtomicReferences into the specific test --- .../autodispose/AutoDisposeCompletableObserverTest.java | 5 ++--- .../com/uber/autodispose/AutoDisposeMaybeObserverTest.java | 6 ++---- .../java/com/uber/autodispose/AutoDisposeObserverTest.java | 5 ++--- .../com/uber/autodispose/AutoDisposeSingleObserverTest.java | 6 ++---- .../com/uber/autodispose/AutoDisposeSubscriberTest.java | 5 ++--- 5 files changed, 10 insertions(+), 17 deletions(-) diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java index 9be043b17..987b4c10f 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java @@ -53,9 +53,6 @@ public class AutoDisposeCompletableObserverTest { } }; - private final AtomicReference atomicObserver = new AtomicReference<>(); - private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); - @After public void resetPlugins() { AutoDisposePlugins.reset(); } @@ -289,6 +286,8 @@ public class AutoDisposeCompletableObserverTest { } @Test public void verifyObserverDelegate() { + final AtomicReference atomicObserver = new AtomicReference<>(); + final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); try { RxJavaPlugins.setOnCompletableSubscribe(new BiFunction() { @Override public CompletableObserver apply(Completable source, CompletableObserver observer) { diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java index 9751941fd..f66799f35 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java @@ -52,10 +52,6 @@ public class AutoDisposeMaybeObserverTest { } }; - private final AtomicReference atomicObserver = new AtomicReference<>(); - private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); - - @After public void resetPlugins() { AutoDisposePlugins.reset(); } @@ -336,6 +332,8 @@ public class AutoDisposeMaybeObserverTest { } @Test public void verifyObserverDelegate() { + final AtomicReference atomicObserver = new AtomicReference<>(); + final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); try { RxJavaPlugins.setOnMaybeSubscribe(new BiFunction() { @Override public MaybeObserver apply(Maybe source, MaybeObserver observer) { diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java index b19b7dd79..a275d8d66 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java @@ -48,9 +48,6 @@ public class AutoDisposeObserverTest { } }; - private final AtomicReference atomicObserver = new AtomicReference(); - private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); - @After public void resetPlugins() { AutoDisposePlugins.reset(); } @@ -265,6 +262,8 @@ public class AutoDisposeObserverTest { } @Test public void verifyObserverDelegate() { + final AtomicReference atomicObserver = new AtomicReference(); + final AtomicReference atomicAutoDisposingObserver = new AtomicReference(); try { RxJavaPlugins.setOnObservableSubscribe(new BiFunction() { @Override public Observer apply(Observable source, Observer observer) { diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java index 6236000ad..1a7b3b18d 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java @@ -18,7 +18,6 @@ import com.uber.autodispose.test.RecordingObserver; import com.uber.autodispose.observers.AutoDisposingSingleObserver; - import io.reactivex.Maybe; import io.reactivex.Single; import io.reactivex.SingleEmitter; @@ -51,9 +50,6 @@ public class AutoDisposeSingleObserverTest { } }; - private final AtomicReference atomicObserver = new AtomicReference<>(); - private final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); - @After public void resetPlugins() { AutoDisposePlugins.reset(); } @@ -303,6 +299,8 @@ public class AutoDisposeSingleObserverTest { } @Test public void verifyObserverDelegate() { + final AtomicReference atomicObserver = new AtomicReference<>(); + final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); try { RxJavaPlugins.setOnSingleSubscribe(new BiFunction() { @Override public SingleObserver apply(Single source, SingleObserver observer) { diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java index f804aac70..f166ee48d 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java @@ -48,9 +48,6 @@ public class AutoDisposeSubscriberTest { - private final AtomicReference atomicSubscriber = new AtomicReference<>(); - private final AtomicReference atomicAutoDisposingSubscriber = new AtomicReference<>(); - @After public void resetPlugins() { AutoDisposePlugins.reset(); } @@ -277,6 +274,8 @@ public class AutoDisposeSubscriberTest { } @Test public void verifySubscriberDelegate() { + final AtomicReference atomicSubscriber = new AtomicReference<>(); + final AtomicReference atomicAutoDisposingSubscriber = new AtomicReference<>(); try { RxJavaPlugins.setOnFlowableSubscribe(new BiFunction() { @Override public Subscriber apply(Flowable source, Subscriber subscriber) { From 71f01542c943d99947be3b707c8c3aa2ae9d83b2 Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Fri, 22 Sep 2017 15:26:49 -0700 Subject: [PATCH 12/13] Fix checkstyle --- .../AutoDisposingCompletableObserverImpl.java | 1 - .../AutoDisposingMaybeObserverImpl.java | 1 - .../AutoDisposingSingleObserverImpl.java | 1 - .../AutoDisposingSubscriberImpl.java | 1 - .../AutoDisposingCompletableObserver.java | 10 +-- .../observers/AutoDisposingMaybeObserver.java | 10 +-- .../observers/AutoDisposingObserver.java | 8 +- .../AutoDisposingSingleObserver.java | 10 +-- .../observers/AutoDisposingSubscriber.java | 12 +-- .../AutoDisposeCompletableObserverTest.java | 87 +++++++++++------- .../AutoDisposeMaybeObserverTest.java | 89 ++++++++++++------- .../autodispose/AutoDisposeObserverTest.java | 5 +- .../AutoDisposeSingleObserverTest.java | 81 +++++++++++------ .../AutoDisposeSubscriberTest.java | 10 +-- 14 files changed, 201 insertions(+), 125 deletions(-) diff --git a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingCompletableObserverImpl.java b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingCompletableObserverImpl.java index e7579e21a..00b956718 100755 --- a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingCompletableObserverImpl.java +++ b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingCompletableObserverImpl.java @@ -19,7 +19,6 @@ import com.uber.autodispose.observers.AutoDisposingCompletableObserver; import io.reactivex.CompletableObserver; import io.reactivex.Maybe; -import io.reactivex.Observer; import io.reactivex.disposables.Disposable; import io.reactivex.disposables.Disposables; import io.reactivex.functions.BiConsumer; diff --git a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingMaybeObserverImpl.java b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingMaybeObserverImpl.java index 79c9a8ed5..2fd67be6e 100755 --- a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingMaybeObserverImpl.java +++ b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingMaybeObserverImpl.java @@ -19,7 +19,6 @@ import com.uber.autodispose.observers.AutoDisposingMaybeObserver; import io.reactivex.Maybe; import io.reactivex.MaybeObserver; -import io.reactivex.Observer; import io.reactivex.disposables.Disposable; import io.reactivex.disposables.Disposables; import io.reactivex.functions.BiConsumer; diff --git a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSingleObserverImpl.java b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSingleObserverImpl.java index a32347be4..e72980843 100755 --- a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSingleObserverImpl.java +++ b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSingleObserverImpl.java @@ -18,7 +18,6 @@ import com.uber.autodispose.observers.AutoDisposingSingleObserver; import io.reactivex.Maybe; -import io.reactivex.Observer; import io.reactivex.SingleObserver; import io.reactivex.disposables.Disposable; import io.reactivex.disposables.Disposables; diff --git a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSubscriberImpl.java b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSubscriberImpl.java index 7f5bd43f6..151b6d643 100755 --- a/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSubscriberImpl.java +++ b/autodispose/src/main/java/com/uber/autodispose/AutoDisposingSubscriberImpl.java @@ -18,7 +18,6 @@ import com.uber.autodispose.observers.AutoDisposingSubscriber; import io.reactivex.Maybe; -import io.reactivex.Observer; import io.reactivex.disposables.Disposable; import io.reactivex.functions.BiConsumer; import io.reactivex.functions.Consumer; diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java index e13e4cdcf..003c4dc44 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java @@ -17,7 +17,6 @@ package com.uber.autodispose.observers; import io.reactivex.CompletableObserver; -import io.reactivex.Observer; import io.reactivex.disposables.Disposable; /** @@ -26,8 +25,9 @@ */ public interface AutoDisposingCompletableObserver extends CompletableObserver, Disposable { - /** - * @return The delegate {@link CompletableObserver} that is used under the hood for introspection purposes. - */ - CompletableObserver delegateObserver(); + /** + * @return The delegate {@link CompletableObserver} that is used under the hood forintrospection + * purposes. + */ + CompletableObserver delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java index 951781614..0e8df02e8 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java @@ -17,7 +17,6 @@ package com.uber.autodispose.observers; import io.reactivex.MaybeObserver; -import io.reactivex.Observer; import io.reactivex.disposables.Disposable; /** @@ -26,8 +25,9 @@ */ public interface AutoDisposingMaybeObserver extends MaybeObserver, Disposable { - /** - * @return The delegate {@link MayberObserver} that is used under the hood for introspection purposes. - */ - MaybeObserver delegateObserver(); + /** + * @return The delegate {@link MayberObserver} that is used under the hood for introspection + * purposes. + */ + MaybeObserver delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java index 5096bc7a7..7f98c7443 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java @@ -25,8 +25,8 @@ */ public interface AutoDisposingObserver extends Observer, Disposable { - /** - * @return The delegate {@link Observer} that is used under the hood for introspection purposes. - */ - Observer delegateObserver(); + /** + * @return The delegate {@link Observer} that is used under the hood for introspection purposes. + */ + Observer delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java index 3b3871f84..d5dabbd47 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java @@ -16,7 +16,6 @@ package com.uber.autodispose.observers; -import io.reactivex.Observer; import io.reactivex.SingleObserver; import io.reactivex.disposables.Disposable; @@ -26,8 +25,9 @@ */ public interface AutoDisposingSingleObserver extends SingleObserver, Disposable { - /** - * @return The delegate {@link SingleObserver} that is used under the hood for introspection purposes. - */ - SingleObserver delegateObserver(); + /** + * @return The delegate {@link SingleObserver} that is used under the hood for introspection + * purposes. + */ + SingleObserver delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java index df9fb9169..ddbe754c7 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java @@ -25,10 +25,12 @@ * A {@link Disposable} {@link Subscriber} that can automatically dispose itself. Interface here * for type safety but enforcement is left to the implementation. */ -public interface AutoDisposingSubscriber extends FlowableSubscriber, Subscription, Disposable { +public interface AutoDisposingSubscriber + extends FlowableSubscriber, Subscription, Disposable { - /** - * @return The delegate {@link Subscriber} that is used under the hood for introspection purposes. - */ - Subscriber delegateSubscriber(); + /** + * @return The delegate {@link Subscriber} that is used under the hood for introspection + * purposes. + */ + Subscriber delegateSubscriber(); } diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java index 987b4c10f..9eef4e9cc 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeCompletableObserverTest.java @@ -24,8 +24,6 @@ import io.reactivex.CompletableObserver; import io.reactivex.CompletableOnSubscribe; import io.reactivex.Maybe; -import io.reactivex.Observable; -import io.reactivex.Observer; import io.reactivex.functions.BiFunction; import io.reactivex.functions.Cancellable; import io.reactivex.functions.Consumer; @@ -35,6 +33,7 @@ import io.reactivex.subjects.BehaviorSubject; import io.reactivex.subjects.CompletableSubject; import io.reactivex.subjects.MaybeSubject; + import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; @@ -48,16 +47,19 @@ public class AutoDisposeCompletableObserverTest { private static final RecordingObserver.Logger LOGGER = new RecordingObserver.Logger() { - @Override public void log(String message) { + @Override + public void log(String message) { System.out.println(AutoDisposeCompletableObserverTest.class.getSimpleName() + ": " + message); } }; - @After public void resetPlugins() { + @After + public void resetPlugins() { AutoDisposePlugins.reset(); } - @Test public void autoDispose_withMaybe_normal() { + @Test + public void autoDispose_withMaybe_normal() { RecordingObserver o = new RecordingObserver<>(LOGGER); CompletableSubject source = CompletableSubject.create(); MaybeSubject lifecycle = MaybeSubject.create(); @@ -78,7 +80,8 @@ public class AutoDisposeCompletableObserverTest { assertThat(lifecycle.hasObservers()).isFalse(); } - @Test public void autoDispose_withMaybe_interrupted() { + @Test + public void autoDispose_withMaybe_interrupted() { RecordingObserver o = new RecordingObserver<>(LOGGER); CompletableSubject source = CompletableSubject.create(); MaybeSubject lifecycle = MaybeSubject.create(); @@ -99,7 +102,8 @@ public class AutoDisposeCompletableObserverTest { o.assertNoMoreEvents(); } - @Test public void autoDispose_withProvider_completion() { + @Test + public void autoDispose_withProvider_completion() { RecordingObserver o = new RecordingObserver<>(LOGGER); CompletableSubject source = CompletableSubject.create(); MaybeSubject scope = MaybeSubject.create(); @@ -119,7 +123,8 @@ public class AutoDisposeCompletableObserverTest { assertThat(scope.hasObservers()).isFalse(); } - @Test public void autoDispose_withProvider_interrupted() { + @Test + public void autoDispose_withProvider_interrupted() { RecordingObserver o = new RecordingObserver<>(LOGGER); CompletableSubject source = CompletableSubject.create(); MaybeSubject scope = MaybeSubject.create(); @@ -142,7 +147,8 @@ public class AutoDisposeCompletableObserverTest { o.assertNoMoreEvents(); } - @Test public void autoDispose_withLifecycleProvider_completion() { + @Test + public void autoDispose_withLifecycleProvider_completion() { RecordingObserver o = new RecordingObserver<>(LOGGER); CompletableSubject source = CompletableSubject.create(); BehaviorSubject lifecycle = BehaviorSubject.createDefault(0); @@ -167,7 +173,8 @@ public class AutoDisposeCompletableObserverTest { assertThat(lifecycle.hasObservers()).isFalse(); } - @Test public void autoDispose_withLifecycleProvider_interrupted() { + @Test + public void autoDispose_withLifecycleProvider_interrupted() { RecordingObserver o = new RecordingObserver<>(LOGGER); CompletableSubject source = CompletableSubject.create(); BehaviorSubject lifecycle = BehaviorSubject.createDefault(0); @@ -195,7 +202,8 @@ public class AutoDisposeCompletableObserverTest { o.assertNoMoreEvents(); } - @Test public void autoDispose_withLifecycleProvider_withoutStartingLifecycle_shouldFail() { + @Test + public void autoDispose_withLifecycleProvider_withoutStartingLifecycle_shouldFail() { BehaviorSubject lifecycle = BehaviorSubject.create(); RecordingObserver o = new RecordingObserver<>(LOGGER); LifecycleScopeProvider provider = makeLifecycleProvider(lifecycle); @@ -207,7 +215,8 @@ public class AutoDisposeCompletableObserverTest { assertThat(o.takeError()).isInstanceOf(LifecycleNotStartedException.class); } - @Test public void autoDispose_withLifecycleProvider_afterLifecycle_shouldFail() { + @Test + public void autoDispose_withLifecycleProvider_afterLifecycle_shouldFail() { BehaviorSubject lifecycle = BehaviorSubject.createDefault(0); lifecycle.onNext(1); lifecycle.onNext(2); @@ -222,9 +231,11 @@ public class AutoDisposeCompletableObserverTest { assertThat(o.takeError()).isInstanceOf(LifecycleEndedException.class); } - @Test public void autoDispose_withProviderAndNoOpPlugin_withoutStarting_shouldFailSilently() { + @Test + public void autoDispose_withProviderAndNoOpPlugin_withoutStarting_shouldFailSilently() { AutoDisposePlugins.setOutsideLifecycleHandler(new Consumer() { - @Override public void accept(OutsideLifecycleException e) throws Exception { } + @Override + public void accept(OutsideLifecycleException e) throws Exception { } }); BehaviorSubject lifecycle = BehaviorSubject.create(); TestObserver o = new TestObserver<>(); @@ -239,9 +250,11 @@ public class AutoDisposeCompletableObserverTest { o.assertNoErrors(); } - @Test public void autoDispose_withProviderAndNoOpPlugin_afterEnding_shouldFailSilently() { + @Test + public void autoDispose_withProviderAndNoOpPlugin_afterEnding_shouldFailSilently() { AutoDisposePlugins.setOutsideLifecycleHandler(new Consumer() { - @Override public void accept(OutsideLifecycleException e) throws Exception { + @Override + public void accept(OutsideLifecycleException e) throws Exception { // Noop } }); @@ -261,9 +274,11 @@ public class AutoDisposeCompletableObserverTest { o.assertNoErrors(); } - @Test public void autoDispose_withProviderAndPlugin_withoutStarting_shouldFailWithWrappedExp() { + @Test + public void autoDispose_withProviderAndPlugin_withoutStarting_shouldFailWithWrappedExp() { AutoDisposePlugins.setOutsideLifecycleHandler(new Consumer() { - @Override public void accept(OutsideLifecycleException e) throws Exception { + @Override + public void accept(OutsideLifecycleException e) throws Exception { // Wrap in an IllegalStateException so we can verify this is the exception we see on the // other side throw new IllegalStateException(e); @@ -278,19 +293,26 @@ public class AutoDisposeCompletableObserverTest { o.assertNoValues(); o.assertError(new Predicate() { - @Override public boolean test(Throwable throwable) throws Exception { + @Override + public boolean test(Throwable throwable) throws Exception { return throwable instanceof IllegalStateException && throwable.getCause() instanceof OutsideLifecycleException; } }); } - @Test public void verifyObserverDelegate() { + @Test + public void verifyObserverDelegate() { final AtomicReference atomicObserver = new AtomicReference<>(); - final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); + final AtomicReference atomicAutoDisposingObserver + = new AtomicReference<>(); try { - RxJavaPlugins.setOnCompletableSubscribe(new BiFunction() { - @Override public CompletableObserver apply(Completable source, CompletableObserver observer) { + RxJavaPlugins.setOnCompletableSubscribe(new BiFunction() { + @Override public CompletableObserver apply( + Completable source, + CompletableObserver observer) { if (atomicObserver.get() == null) { atomicObserver.set(observer); } else if (atomicAutoDisposingObserver.get() == null) { @@ -303,22 +325,27 @@ public class AutoDisposeCompletableObserverTest { Completable.complete().to(new CompletableScoper(Maybe.never())).subscribe(); assertThat(atomicAutoDisposingObserver.get()).isNotNull(); - assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingCompletableObserver.class); - assertThat(((AutoDisposingCompletableObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); - assertThat(((AutoDisposingCompletableObserver)atomicAutoDisposingObserver.get()).delegateObserver()) - .isSameAs(atomicObserver.get()); + assertThat(atomicAutoDisposingObserver.get()) + .isInstanceOf(AutoDisposingCompletableObserver.class); + assertThat(((AutoDisposingCompletableObserver) atomicAutoDisposingObserver.get()) + .delegateObserver()).isNotNull(); + assertThat(((AutoDisposingCompletableObserver) atomicAutoDisposingObserver.get()) + .delegateObserver()).isSameAs(atomicObserver.get()); } finally { RxJavaPlugins.reset(); } } - @Test public void verifyCancellation() throws Exception { + @Test + public void verifyCancellation() throws Exception { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java Completable source = Completable.create(new CompletableOnSubscribe() { - @Override public void subscribe(CompletableEmitter e) throws Exception { + @Override + public void subscribe(CompletableEmitter e) throws Exception { e.setCancellable(new Cancellable() { - @Override public void cancel() throws Exception { + @Override + public void cancel() throws Exception { i.incrementAndGet(); } }); diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java index f66799f35..b9959b136 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeMaybeObserverTest.java @@ -19,13 +19,10 @@ import com.uber.autodispose.test.RecordingObserver; import com.uber.autodispose.observers.AutoDisposingMaybeObserver; -import io.reactivex.CompletableObserver; import io.reactivex.Maybe; import io.reactivex.MaybeEmitter; import io.reactivex.MaybeObserver; import io.reactivex.MaybeOnSubscribe; -import io.reactivex.Observable; -import io.reactivex.Observer; import io.reactivex.functions.BiFunction; import io.reactivex.functions.Cancellable; import io.reactivex.functions.Consumer; @@ -34,6 +31,7 @@ import io.reactivex.plugins.RxJavaPlugins; import io.reactivex.subjects.BehaviorSubject; import io.reactivex.subjects.MaybeSubject; + import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; @@ -47,16 +45,19 @@ public class AutoDisposeMaybeObserverTest { private static final RecordingObserver.Logger LOGGER = new RecordingObserver.Logger() { - @Override public void log(String message) { + @Override + public void log(String message) { System.out.println(AutoDisposeMaybeObserverTest.class.getSimpleName() + ": " + message); } }; - @After public void resetPlugins() { + @After + public void resetPlugins() { AutoDisposePlugins.reset(); } - @Test public void autoDispose_withMaybe_normal() { + @Test + public void autoDispose_withMaybe_normal() { RecordingObserver o = new RecordingObserver<>(LOGGER); MaybeSubject source = MaybeSubject.create(); MaybeSubject lifecycle = MaybeSubject.create(); @@ -77,23 +78,27 @@ public class AutoDisposeMaybeObserverTest { assertThat(lifecycle.hasObservers()).isFalse(); } - @Test public void autoDispose_withSuperClassGenerics_compilesFine() { + @Test + public void autoDispose_withSuperClassGenerics_compilesFine() { Maybe.just(new BClass()) .to(new MaybeScoper(Maybe.never())) .subscribe(new Consumer() { - @Override public void accept(AClass aClass) throws Exception { + @Override + public void accept(AClass aClass) throws Exception { } }); } - @Test public void autoDispose_noGenericsOnEmpty_isFine() { + @Test + public void autoDispose_noGenericsOnEmpty_isFine() { Maybe.just(new BClass()) .to(new MaybeScoper<>(Maybe.never())) .subscribe(); } - @Test public void autoDispose_withMaybe_interrupted() { + @Test + public void autoDispose_withMaybe_interrupted() { RecordingObserver o = new RecordingObserver<>(LOGGER); MaybeSubject source = MaybeSubject.create(); MaybeSubject lifecycle = MaybeSubject.create(); @@ -101,7 +106,8 @@ public class AutoDisposeMaybeObserverTest { .subscribe(o); source.to(new MaybeScoper(lifecycle)) .subscribe(new Consumer() { - @Override public void accept(Integer integer) throws Exception { + @Override + public void accept(Integer integer) throws Exception { } }); @@ -120,7 +126,8 @@ public class AutoDisposeMaybeObserverTest { o.assertNoMoreEvents(); } - @Test public void autoDispose_withProvider_success() { + @Test + public void autoDispose_withProvider_success() { RecordingObserver o = new RecordingObserver<>(LOGGER); MaybeSubject source = MaybeSubject.create(); BehaviorSubject lifecycle = BehaviorSubject.createDefault(0); @@ -145,7 +152,8 @@ public class AutoDisposeMaybeObserverTest { assertThat(lifecycle.hasObservers()).isFalse(); } - @Test public void autoDispose_withProvider_completion() { + @Test + public void autoDispose_withProvider_completion() { RecordingObserver o = new RecordingObserver<>(LOGGER); MaybeSubject source = MaybeSubject.create(); MaybeSubject scope = MaybeSubject.create(); @@ -165,7 +173,8 @@ public class AutoDisposeMaybeObserverTest { assertThat(scope.hasObservers()).isFalse(); } - @Test public void autoDispose_withProvider_interrupted() { + @Test + public void autoDispose_withProvider_interrupted() { RecordingObserver o = new RecordingObserver<>(LOGGER); MaybeSubject source = MaybeSubject.create(); MaybeSubject scope = MaybeSubject.create(); @@ -188,7 +197,8 @@ public class AutoDisposeMaybeObserverTest { o.assertNoMoreEvents(); } - @Test public void autoDispose_withLifecycleProvider_completion() { + @Test + public void autoDispose_withLifecycleProvider_completion() { RecordingObserver o = new RecordingObserver<>(LOGGER); MaybeSubject source = MaybeSubject.create(); BehaviorSubject lifecycle = BehaviorSubject.createDefault(0); @@ -213,7 +223,8 @@ public class AutoDisposeMaybeObserverTest { assertThat(lifecycle.hasObservers()).isFalse(); } - @Test public void autoDispose_withLifecycleProvider_interrupted() { + @Test + public void autoDispose_withLifecycleProvider_interrupted() { RecordingObserver o = new RecordingObserver<>(LOGGER); MaybeSubject source = MaybeSubject.create(); BehaviorSubject lifecycle = BehaviorSubject.createDefault(0); @@ -241,7 +252,8 @@ public class AutoDisposeMaybeObserverTest { o.assertNoMoreEvents(); } - @Test public void autoDispose_withLifecycleProvider_withoutStartingLifecycle_shouldFail() { + @Test + public void autoDispose_withLifecycleProvider_withoutStartingLifecycle_shouldFail() { BehaviorSubject lifecycle = BehaviorSubject.create(); RecordingObserver o = new RecordingObserver<>(LOGGER); LifecycleScopeProvider provider = makeLifecycleProvider(lifecycle); @@ -253,7 +265,8 @@ public class AutoDisposeMaybeObserverTest { assertThat(o.takeError()).isInstanceOf(LifecycleNotStartedException.class); } - @Test public void autoDispose_withLifecycleProvider_afterLifecycle_shouldFail() { + @Test + public void autoDispose_withLifecycleProvider_afterLifecycle_shouldFail() { BehaviorSubject lifecycle = BehaviorSubject.createDefault(0); lifecycle.onNext(1); lifecycle.onNext(2); @@ -268,9 +281,11 @@ public class AutoDisposeMaybeObserverTest { assertThat(o.takeError()).isInstanceOf(LifecycleEndedException.class); } - @Test public void autoDispose_withProviderAndNoOpPlugin_withoutStarting_shouldFailSilently() { + @Test + public void autoDispose_withProviderAndNoOpPlugin_withoutStarting_shouldFailSilently() { AutoDisposePlugins.setOutsideLifecycleHandler(new Consumer() { - @Override public void accept(OutsideLifecycleException e) throws Exception { } + @Override + public void accept(OutsideLifecycleException e) throws Exception { } }); BehaviorSubject lifecycle = BehaviorSubject.create(); TestObserver o = new TestObserver<>(); @@ -285,9 +300,11 @@ public class AutoDisposeMaybeObserverTest { o.assertNoErrors(); } - @Test public void autoDispose_withProviderAndNoOpPlugin_afterEnding_shouldFailSilently() { + @Test + public void autoDispose_withProviderAndNoOpPlugin_afterEnding_shouldFailSilently() { AutoDisposePlugins.setOutsideLifecycleHandler(new Consumer() { - @Override public void accept(OutsideLifecycleException e) throws Exception { + @Override + public void accept(OutsideLifecycleException e) throws Exception { // Noop } }); @@ -307,9 +324,11 @@ public class AutoDisposeMaybeObserverTest { o.assertNoErrors(); } - @Test public void autoDispose_withProviderAndPlugin_withoutStarting_shouldFailWithWrappedExp() { + @Test + public void autoDispose_withProviderAndPlugin_withoutStarting_shouldFailWithWrappedExp() { AutoDisposePlugins.setOutsideLifecycleHandler(new Consumer() { - @Override public void accept(OutsideLifecycleException e) throws Exception { + @Override + public void accept(OutsideLifecycleException e) throws Exception { // Wrap in an IllegalStateException so we can verify this is the exception we see on the // other side throw new IllegalStateException(e); @@ -324,14 +343,16 @@ public class AutoDisposeMaybeObserverTest { o.assertNoValues(); o.assertError(new Predicate() { - @Override public boolean test(Throwable throwable) throws Exception { + @Override + public boolean test(Throwable throwable) throws Exception { return throwable instanceof IllegalStateException && throwable.getCause() instanceof OutsideLifecycleException; } }); } - @Test public void verifyObserverDelegate() { + @Test + public void verifyObserverDelegate() { final AtomicReference atomicObserver = new AtomicReference<>(); final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); try { @@ -350,21 +371,25 @@ public class AutoDisposeMaybeObserverTest { assertThat(atomicAutoDisposingObserver.get()).isNotNull(); assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingMaybeObserver.class); - assertThat(((AutoDisposingMaybeObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); - assertThat(((AutoDisposingMaybeObserver)atomicAutoDisposingObserver.get()).delegateObserver()) - .isSameAs(atomicObserver.get()); + assertThat(((AutoDisposingMaybeObserver) atomicAutoDisposingObserver.get()) + .delegateObserver()).isNotNull(); + assertThat(((AutoDisposingMaybeObserver) atomicAutoDisposingObserver.get()) + .delegateObserver()).isSameAs(atomicObserver.get()); } finally { RxJavaPlugins.reset(); } } - @Test public void verifyCancellation() throws Exception { + @Test + public void verifyCancellation() throws Exception { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java Maybe source = Maybe.create(new MaybeOnSubscribe() { - @Override public void subscribe(MaybeEmitter e) throws Exception { + @Override + public void subscribe(MaybeEmitter e) throws Exception { e.setCancellable(new Cancellable() { - @Override public void cancel() throws Exception { + @Override + public void cancel() throws Exception { i.incrementAndGet(); } }); diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java index a275d8d66..2871b10f4 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeObserverTest.java @@ -280,8 +280,9 @@ public class AutoDisposeObserverTest { assertThat(atomicAutoDisposingObserver.get()).isNotNull(); assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingObserver.class); - assertThat(((AutoDisposingObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); - assertThat(((AutoDisposingObserver)atomicAutoDisposingObserver.get()).delegateObserver()) + assertThat(((AutoDisposingObserver) atomicAutoDisposingObserver.get()).delegateObserver()) + .isNotNull(); + assertThat(((AutoDisposingObserver) atomicAutoDisposingObserver.get()).delegateObserver()) .isSameAs(atomicObserver.get()); } finally { RxJavaPlugins.reset(); diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java index 1a7b3b18d..7f137fb61 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSingleObserverTest.java @@ -18,6 +18,7 @@ import com.uber.autodispose.test.RecordingObserver; import com.uber.autodispose.observers.AutoDisposingSingleObserver; + import io.reactivex.Maybe; import io.reactivex.Single; import io.reactivex.SingleEmitter; @@ -32,6 +33,7 @@ import io.reactivex.subjects.BehaviorSubject; import io.reactivex.subjects.MaybeSubject; import io.reactivex.subjects.SingleSubject; + import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; @@ -45,16 +47,19 @@ public class AutoDisposeSingleObserverTest { private static final RecordingObserver.Logger LOGGER = new RecordingObserver.Logger() { - @Override public void log(String message) { + @Override + public void log(String message) { System.out.println(AutoDisposeSingleObserverTest.class.getSimpleName() + ": " + message); } }; - @After public void resetPlugins() { + @After + public void resetPlugins() { AutoDisposePlugins.reset(); } - @Test public void autoDispose_withMaybe_normal() { + @Test + public void autoDispose_withMaybe_normal() { RecordingObserver o = new RecordingObserver<>(LOGGER); SingleSubject source = SingleSubject.create(); MaybeSubject lifecycle = MaybeSubject.create(); @@ -75,23 +80,27 @@ public class AutoDisposeSingleObserverTest { assertThat(lifecycle.hasObservers()).isFalse(); } - @Test public void autoDispose_withSuperClassGenerics_compilesFine() { + @Test + public void autoDispose_withSuperClassGenerics_compilesFine() { Single.just(new BClass()) .to(new SingleScoper(Maybe.never())) .subscribe(new Consumer() { - @Override public void accept(AClass aClass) throws Exception { + @Override + public void accept(AClass aClass) throws Exception { } }); } - @Test public void autoDispose_noGenericsOnEmpty_isFine() { + @Test + public void autoDispose_noGenericsOnEmpty_isFine() { Single.just(new BClass()) .to(new SingleScoper<>(Maybe.never())) .subscribe(); } - @Test public void autoDispose_withMaybe_interrupted() { + @Test + public void autoDispose_withMaybe_interrupted() { RecordingObserver o = new RecordingObserver<>(LOGGER); SingleSubject source = SingleSubject.create(); MaybeSubject lifecycle = MaybeSubject.create(); @@ -112,7 +121,8 @@ public class AutoDisposeSingleObserverTest { o.assertNoMoreEvents(); } - @Test public void autoDispose_withProvider() { + @Test + public void autoDispose_withProvider() { RecordingObserver o = new RecordingObserver<>(LOGGER); SingleSubject source = SingleSubject.create(); MaybeSubject scope = MaybeSubject.create(); @@ -133,7 +143,8 @@ public class AutoDisposeSingleObserverTest { assertThat(scope.hasObservers()).isFalse(); } - @Test public void autoDispose_withProvider_interrupted() { + @Test + public void autoDispose_withProvider_interrupted() { RecordingObserver o = new RecordingObserver<>(LOGGER); SingleSubject source = SingleSubject.create(); MaybeSubject scope = MaybeSubject.create(); @@ -155,7 +166,8 @@ public class AutoDisposeSingleObserverTest { o.assertNoMoreEvents(); } - @Test public void autoDispose_withLifecycleProvider() { + @Test + public void autoDispose_withLifecycleProvider() { RecordingObserver o = new RecordingObserver<>(LOGGER); SingleSubject source = SingleSubject.create(); BehaviorSubject lifecycle = BehaviorSubject.createDefault(0); @@ -181,7 +193,8 @@ public class AutoDisposeSingleObserverTest { assertThat(lifecycle.hasObservers()).isFalse(); } - @Test public void autoDispose_withLifecycleProvider_interrupted() { + @Test + public void autoDispose_withLifecycleProvider_interrupted() { RecordingObserver o = new RecordingObserver<>(LOGGER); SingleSubject source = SingleSubject.create(); BehaviorSubject lifecycle = BehaviorSubject.createDefault(0); @@ -208,7 +221,8 @@ public class AutoDisposeSingleObserverTest { o.assertNoMoreEvents(); } - @Test public void autoDispose_withProvider_withoutStartingLifecycle_shouldFail() { + @Test + public void autoDispose_withProvider_withoutStartingLifecycle_shouldFail() { BehaviorSubject lifecycle = BehaviorSubject.create(); RecordingObserver o = new RecordingObserver<>(LOGGER); LifecycleScopeProvider provider = makeLifecycleProvider(lifecycle); @@ -220,7 +234,8 @@ public class AutoDisposeSingleObserverTest { assertThat(o.takeError()).isInstanceOf(LifecycleNotStartedException.class); } - @Test public void autoDispose_withProvider_afterLifecycle_shouldFail() { + @Test + public void autoDispose_withProvider_afterLifecycle_shouldFail() { BehaviorSubject lifecycle = BehaviorSubject.createDefault(0); lifecycle.onNext(1); lifecycle.onNext(2); @@ -235,9 +250,11 @@ public class AutoDisposeSingleObserverTest { assertThat(o.takeError()).isInstanceOf(LifecycleEndedException.class); } - @Test public void autoDispose_withProviderAndNoOpPlugin_withoutStarting_shouldFailSilently() { + @Test + public void autoDispose_withProviderAndNoOpPlugin_withoutStarting_shouldFailSilently() { AutoDisposePlugins.setOutsideLifecycleHandler(new Consumer() { - @Override public void accept(OutsideLifecycleException e) throws Exception { } + @Override + public void accept(OutsideLifecycleException e) throws Exception { } }); BehaviorSubject lifecycle = BehaviorSubject.create(); TestObserver o = new TestObserver<>(); @@ -252,9 +269,11 @@ public class AutoDisposeSingleObserverTest { o.assertNoErrors(); } - @Test public void autoDispose_withProviderAndNoOpPlugin_afterEnding_shouldFailSilently() { + @Test + public void autoDispose_withProviderAndNoOpPlugin_afterEnding_shouldFailSilently() { AutoDisposePlugins.setOutsideLifecycleHandler(new Consumer() { - @Override public void accept(OutsideLifecycleException e) throws Exception { + @Override + public void accept(OutsideLifecycleException e) throws Exception { // Noop } }); @@ -274,9 +293,11 @@ public class AutoDisposeSingleObserverTest { o.assertNoErrors(); } - @Test public void autoDispose_withProviderAndPlugin_withoutStarting_shouldFailWithExp() { + @Test + public void autoDispose_withProviderAndPlugin_withoutStarting_shouldFailWithExp() { AutoDisposePlugins.setOutsideLifecycleHandler(new Consumer() { - @Override public void accept(OutsideLifecycleException e) throws Exception { + @Override + public void accept(OutsideLifecycleException e) throws Exception { // Wrap in an IllegalStateException so we can verify this is the exception we see on the // other side throw new IllegalStateException(e); @@ -291,14 +312,16 @@ public class AutoDisposeSingleObserverTest { o.assertNoValues(); o.assertError(new Predicate() { - @Override public boolean test(Throwable throwable) throws Exception { + @Override + public boolean test(Throwable throwable) throws Exception { return throwable instanceof IllegalStateException && throwable.getCause() instanceof OutsideLifecycleException; } }); } - @Test public void verifyObserverDelegate() { + @Test + public void verifyObserverDelegate() { final AtomicReference atomicObserver = new AtomicReference<>(); final AtomicReference atomicAutoDisposingObserver = new AtomicReference<>(); try { @@ -317,21 +340,25 @@ public class AutoDisposeSingleObserverTest { assertThat(atomicAutoDisposingObserver.get()).isNotNull(); assertThat(atomicAutoDisposingObserver.get()).isInstanceOf(AutoDisposingSingleObserver.class); - assertThat(((AutoDisposingSingleObserver)atomicAutoDisposingObserver.get()).delegateObserver()).isNotNull(); - assertThat(((AutoDisposingSingleObserver)atomicAutoDisposingObserver.get()).delegateObserver()) - .isSameAs(atomicObserver.get()); + assertThat(((AutoDisposingSingleObserver) atomicAutoDisposingObserver.get()) + .delegateObserver()).isNotNull(); + assertThat(((AutoDisposingSingleObserver) atomicAutoDisposingObserver.get()) + .delegateObserver()).isSameAs(atomicObserver.get()); } finally { RxJavaPlugins.reset(); } } - @Test public void verifyCancellation() throws Exception { + @Test + public void verifyCancellation() throws Exception { final AtomicInteger i = new AtomicInteger(); //noinspection unchecked because Java Single source = Single.create(new SingleOnSubscribe() { - @Override public void subscribe(SingleEmitter e) throws Exception { + @Override + public void subscribe(SingleEmitter e) throws Exception { e.setCancellable(new Cancellable() { - @Override public void cancel() throws Exception { + @Override + public void cancel() throws Exception { i.incrementAndGet(); } }); diff --git a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java index f166ee48d..179ce0cbe 100755 --- a/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java +++ b/autodispose/src/test/java/com/uber/autodispose/AutoDisposeSubscriberTest.java @@ -23,9 +23,6 @@ import io.reactivex.FlowableEmitter; import io.reactivex.FlowableOnSubscribe; import io.reactivex.Maybe; -import io.reactivex.MaybeObserver; -import io.reactivex.Single; -import io.reactivex.SingleObserver; import io.reactivex.disposables.Disposable; import io.reactivex.functions.BiFunction; import io.reactivex.functions.Cancellable; @@ -294,9 +291,10 @@ public class AutoDisposeSubscriberTest { assertThat(atomicAutoDisposingSubscriber.get()).isNotNull(); assertThat(atomicAutoDisposingSubscriber.get()).isInstanceOf(AutoDisposingSubscriber.class); - assertThat(((AutoDisposingSubscriber)atomicAutoDisposingSubscriber.get()).delegateSubscriber()).isNotNull(); - assertThat(((AutoDisposingSubscriber)atomicAutoDisposingSubscriber.get()).delegateSubscriber()) - .isSameAs(atomicSubscriber.get()); + assertThat(((AutoDisposingSubscriber) atomicAutoDisposingSubscriber.get()) + .delegateSubscriber()).isNotNull(); + assertThat(((AutoDisposingSubscriber) atomicAutoDisposingSubscriber.get()) + .delegateSubscriber()).isSameAs(atomicSubscriber.get()); } finally { RxJavaPlugins.reset(); } From bda104041416b57787962828533c18fde2ceeb3b Mon Sep 17 00:00:00 2001 From: Matt Wysocki Date: Fri, 22 Sep 2017 15:35:15 -0700 Subject: [PATCH 13/13] Add comments and @Experimental annotation --- .../observers/AutoDisposingCompletableObserver.java | 4 +++- .../autodispose/observers/AutoDisposingMaybeObserver.java | 4 +++- .../uber/autodispose/observers/AutoDisposingObserver.java | 5 ++++- .../autodispose/observers/AutoDisposingSingleObserver.java | 4 +++- .../uber/autodispose/observers/AutoDisposingSubscriber.java | 4 +++- 5 files changed, 16 insertions(+), 5 deletions(-) diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java index 003c4dc44..a9b766ae6 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingCompletableObserver.java @@ -17,6 +17,7 @@ package com.uber.autodispose.observers; import io.reactivex.CompletableObserver; +import io.reactivex.annotations.Experimental; import io.reactivex.disposables.Disposable; /** @@ -27,7 +28,8 @@ public interface AutoDisposingCompletableObserver extends CompletableObserver, D /** * @return The delegate {@link CompletableObserver} that is used under the hood forintrospection - * purposes. + * purposes. This will be updated once LambdaIntrospection is out of @Experimental in RxJava. */ + @Experimental CompletableObserver delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java index 0e8df02e8..d4db418ec 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingMaybeObserver.java @@ -17,6 +17,7 @@ package com.uber.autodispose.observers; import io.reactivex.MaybeObserver; +import io.reactivex.annotations.Experimental; import io.reactivex.disposables.Disposable; /** @@ -27,7 +28,8 @@ public interface AutoDisposingMaybeObserver extends MaybeObserver, Disposa /** * @return The delegate {@link MayberObserver} that is used under the hood for introspection - * purposes. + * purposes. This will be updated once LambdaIntrospection is out of @Experimental in RxJava. */ + @Experimental MaybeObserver delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java index 7f98c7443..b8aeda459 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingObserver.java @@ -17,6 +17,7 @@ package com.uber.autodispose.observers; import io.reactivex.Observer; +import io.reactivex.annotations.Experimental; import io.reactivex.disposables.Disposable; /** @@ -26,7 +27,9 @@ public interface AutoDisposingObserver extends Observer, Disposable { /** - * @return The delegate {@link Observer} that is used under the hood for introspection purposes. + * @return The delegate {@link Observer} that is used under the hood for introspection purpose. + * This will be updated once LambdaIntrospection is out of @Experimental in RxJava. */ + @Experimental Observer delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java index d5dabbd47..d013acb70 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSingleObserver.java @@ -17,6 +17,7 @@ package com.uber.autodispose.observers; import io.reactivex.SingleObserver; +import io.reactivex.annotations.Experimental; import io.reactivex.disposables.Disposable; /** @@ -27,7 +28,8 @@ public interface AutoDisposingSingleObserver extends SingleObserver, Dispo /** * @return The delegate {@link SingleObserver} that is used under the hood for introspection - * purposes. + * purposes. This will be updated once LambdaIntrospection is out of @Experimental in RxJava. */ + @Experimental SingleObserver delegateObserver(); } diff --git a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java index ddbe754c7..2740dc1ff 100644 --- a/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java +++ b/autodispose/src/main/java/com/uber/autodispose/observers/AutoDisposingSubscriber.java @@ -17,6 +17,7 @@ package com.uber.autodispose.observers; import io.reactivex.FlowableSubscriber; +import io.reactivex.annotations.Experimental; import io.reactivex.disposables.Disposable; import org.reactivestreams.Subscriber; import org.reactivestreams.Subscription; @@ -30,7 +31,8 @@ public interface AutoDisposingSubscriber /** * @return The delegate {@link Subscriber} that is used under the hood for introspection - * purposes. + * purposes. This will be updated once LambdaIntrospection is out of @Experimental in RxJava. */ + @Experimental Subscriber delegateSubscriber(); }