3.x rename on error resume next methods to disambiguate when calling from kotlin (#6551) (#6556)

luis-cortes · akarnokd · commit b40a892b9fd1 · 2019-07-04T10:19:13.000+02:00
* #6551 Renaming Observable.onErrorResumeNext to Observable.onErrorResumeWith, removing unnecessary cast from null tests, and updating Observable.onErrorResumeWith's JavaDoc to reference correct parameter name, renamed test classes since the distinctions in their names are no longer necessary. * #6551 Renaming Maybe.onErrorResumeNext(MaybeSource) to Maybe.onErrorResumeWith(MaybeSource), renamed some of the affected unit tests, and updated JavaDoc. * #6551 Renaming Single.onErrorResumeNext(Single) to Single.onErrorResumeWith(Single), renamed an affected unit test, updated JavaDoc, and removed redundant casts. * #6551 Changing Single.onErrorResumeWith parameter from Single<? extends T> to SingleSource<? extends T> * #6551 Renaming Flowable.onErrorResumeNext(Publisher) to Flowable.onErrorResumeWith(Publisher), renaming some affected tests, deleted duplicated unit test that arose from being able to remove redundant casts, updated JavaDocs.
diff --git a/src/main/java/io/reactivex/Flowable.java b/src/main/java/io/reactivex/Flowable.java
@@ -12197,9 +12197,9 @@ public final Flowable<T> onErrorResumeNext(Function<? super Throwable, ? extends
      * <p>
      * By default, when a Publisher encounters an error that prevents it from emitting the expected item to
      * its {@link Subscriber}, the Publisher invokes its Subscriber's {@code onError} method, and then quits
-     * without invoking any more of its Subscriber's methods. The {@code onErrorResumeNext} method changes this
+     * without invoking any more of its Subscriber's methods. The {@code onErrorResumeWith} method changes this
      * behavior. If you pass another Publisher ({@code resumeSequence}) to a Publisher's
-     * {@code onErrorResumeNext} method, if the original Publisher encounters an error, instead of invoking its
+     * {@code onErrorResumeWith} method, if the original Publisher encounters an error, instead of invoking its
      * Subscriber's {@code onError} method, it will instead relinquish control to {@code resumeSequence} which
      * will invoke the Subscriber's {@link Subscriber#onNext onNext} method if it is able to do so. In such a case,
      * because no Publisher necessarily invokes {@code onError}, the Subscriber may never know that an error
@@ -12215,7 +12215,7 @@ public final Flowable<T> onErrorResumeNext(Function<? super Throwable, ? extends
      *  {@code IllegalStateException} when the source {@code Publisher} completes or
      *  {@code MissingBackpressureException} is signaled somewhere downstream.</dd>
      *  <dt><b>Scheduler:</b></dt>
-     *  <dd>{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
+     *  <dd>{@code onErrorResumeWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
      * @param next
@@ -12228,7 +12228,7 @@ public final Flowable<T> onErrorResumeNext(Function<? super Throwable, ? extends
     @NonNull
     @BackpressureSupport(BackpressureKind.FULL)
     @SchedulerSupport(SchedulerSupport.NONE)
-    public final Flowable<T> onErrorResumeNext(final Publisher<? extends T> next) {
+    public final Flowable<T> onErrorResumeWith(final Publisher<? extends T> next) {
         ObjectHelper.requireNonNull(next, "next is null");
         return onErrorResumeNext(Functions.justFunction(next));
     }
diff --git a/src/main/java/io/reactivex/Maybe.java b/src/main/java/io/reactivex/Maybe.java
@@ -3732,7 +3732,7 @@ public final Maybe<T> onErrorComplete(final Predicate<? super Throwable> predica
      * encountered.
      * <dl>
      *  <dt><b>Scheduler:</b></dt>
-     *  <dd>{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
+     *  <dd>{@code onErrorResumeWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
      * @param next
@@ -3744,7 +3744,7 @@ public final Maybe<T> onErrorComplete(final Predicate<? super Throwable> predica
     @CheckReturnValue
     @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
-    public final Maybe<T> onErrorResumeNext(final MaybeSource<? extends T> next) {
+    public final Maybe<T> onErrorResumeWith(final MaybeSource<? extends T> next) {
         ObjectHelper.requireNonNull(next, "next is null");
         return onErrorResumeNext(Functions.justFunction(next));
     }
diff --git a/src/main/java/io/reactivex/Observable.java b/src/main/java/io/reactivex/Observable.java
@@ -10126,10 +10126,10 @@ public final Observable<T> onErrorResumeNext(Function<? super Throwable, ? exten
      * <p>
      * By default, when an ObservableSource encounters an error that prevents it from emitting the expected item to
      * its {@link Observer}, the ObservableSource invokes its Observer's {@code onError} method, and then quits
-     * without invoking any more of its Observer's methods. The {@code onErrorResumeNext} method changes this
-     * behavior. If you pass another ObservableSource ({@code resumeSequence}) to an ObservableSource's
-     * {@code onErrorResumeNext} method, if the original ObservableSource encounters an error, instead of invoking its
-     * Observer's {@code onError} method, it will instead relinquish control to {@code resumeSequence} which
+     * without invoking any more of its Observer's methods. The {@code onErrorResumeWith} method changes this
+     * behavior. If you pass another ObservableSource ({@code next}) to an ObservableSource's
+     * {@code onErrorResumeWith} method, if the original ObservableSource encounters an error, instead of invoking its
+     * Observer's {@code onError} method, it will instead relinquish control to {@code next} which
      * will invoke the Observer's {@link Observer#onNext onNext} method if it is able to do so. In such a case,
      * because no ObservableSource necessarily invokes {@code onError}, the Observer may never know that an error
      * happened.
@@ -10138,7 +10138,7 @@ public final Observable<T> onErrorResumeNext(Function<? super Throwable, ? exten
      * encountered.
      * <dl>
      *  <dt><b>Scheduler:</b></dt>
-     *  <dd>{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
+     *  <dd>{@code onErrorResumeWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
      * @param next
@@ -10149,7 +10149,7 @@ public final Observable<T> onErrorResumeNext(Function<? super Throwable, ? exten
      */
     @CheckReturnValue
     @SchedulerSupport(SchedulerSupport.NONE)
-    public final Observable<T> onErrorResumeNext(final ObservableSource<? extends T> next) {
+    public final Observable<T> onErrorResumeWith(final ObservableSource<? extends T> next) {
         ObjectHelper.requireNonNull(next, "next is null");
         return onErrorResumeNext(Functions.justFunction(next));
     }
diff --git a/src/main/java/io/reactivex/Single.java b/src/main/java/io/reactivex/Single.java
@@ -3207,9 +3207,9 @@ public final Single<T> onErrorReturnItem(final T value) {
      * <p>
      * By default, when a Single encounters an error that prevents it from emitting the expected item to
      * its {@link SingleObserver}, the Single invokes its SingleObserver's {@code onError} method, and then quits
-     * without invoking any more of its SingleObserver's methods. The {@code onErrorResumeNext} method changes this
+     * without invoking any more of its SingleObserver's methods. The {@code onErrorResumeWith} method changes this
      * behavior. If you pass another Single ({@code resumeSingleInCaseOfError}) to a Single's
-     * {@code onErrorResumeNext} method, if the original Single encounters an error, instead of invoking its
+     * {@code onErrorResumeWith} method, if the original Single encounters an error, instead of invoking its
      * SingleObserver's {@code onError} method, it will instead relinquish control to {@code resumeSingleInCaseOfError} which
      * will invoke the SingleObserver's {@link SingleObserver#onSuccess onSuccess} method if it is able to do so. In such a case,
      * because no Single necessarily invokes {@code onError}, the SingleObserver may never know that an error
@@ -3219,7 +3219,7 @@ public final Single<T> onErrorReturnItem(final T value) {
      * encountered.
      * <dl>
      * <dt><b>Scheduler:</b></dt>
-     * <dd>{@code onErrorResumeNext} does not operate by default on a particular {@link Scheduler}.</dd>
+     * <dd>{@code onErrorResumeWith} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
      *
      * @param resumeSingleInCaseOfError a Single that will take control if source Single encounters an error.
@@ -3229,7 +3229,7 @@ public final Single<T> onErrorReturnItem(final T value) {
     @CheckReturnValue
     @NonNull
     @SchedulerSupport(SchedulerSupport.NONE)
-    public final Single<T> onErrorResumeNext(final Single<? extends T> resumeSingleInCaseOfError) {
+    public final Single<T> onErrorResumeWith(final SingleSource<? extends T> resumeSingleInCaseOfError) {
         ObjectHelper.requireNonNull(resumeSingleInCaseOfError, "resumeSingleInCaseOfError is null");
         return onErrorResumeNext(Functions.justFunction(resumeSingleInCaseOfError));
     }
diff --git a/src/test/java/io/reactivex/flowable/FlowableNullTests.java b/src/test/java/io/reactivex/flowable/FlowableNullTests.java
@@ -1646,8 +1646,8 @@ public void onBackpressureDropActionNull() {
     }
 
     @Test(expected = NullPointerException.class)
-    public void onErrorResumeNextFunctionNull() {
-        just1.onErrorResumeNext((Function<Throwable, Publisher<Integer>>)null);
+    public void onErrorResumeNextNull() {
+        just1.onErrorResumeNext(null);
     }
 
     @Test
@@ -1669,8 +1669,8 @@ public Publisher<Object> apply(Throwable e) {
     }
 
     @Test(expected = NullPointerException.class)
-    public void onErrorResumeNextPublisherNull() {
-        just1.onErrorResumeNext((Publisher<Integer>)null);
+    public void onErrorResumeWithNull() {
+        just1.onErrorResumeWith(null);
     }
 
     @Test(expected = NullPointerException.class)
@@ -2958,11 +2958,6 @@ public void sampleFlowableNull() {
         just1.sample(null);
     }
 
-    @Test(expected = NullPointerException.class)
-    public void onErrorResumeNextFlowableNull() {
-        just1.onErrorResumeNext((Flowable<Integer>)null);
-    }
-
     @SuppressWarnings("unchecked")
     @Test(expected = NullPointerException.class)
     public void combineLatestDelayErrorVarargsFunctionReturnsNull() {
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableDelayTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableDelayTest.java
@@ -928,7 +928,7 @@ public void accept(Throwable throwable) throws Exception {
                         latch.countDown();
                     }
                 })
-                .onErrorResumeNext(Flowable.<String>empty())
+                .onErrorResumeWith(Flowable.<String>empty())
                 .subscribe();
 
         latch.await();
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnErrorResumeNextViaFlowableTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowableOnErrorResumeNextViaFlowableTest.java
@@ -39,7 +39,7 @@ public void resumeNext() {
         TestObservable f = new TestObservable(s, "one", "fail", "two", "three");
         Flowable<String> w = Flowable.unsafeCreate(f);
         Flowable<String> resume = Flowable.just("twoResume", "threeResume");
-        Flowable<String> flowable = w.onErrorResumeNext(resume);
+        Flowable<String> flowable = w.onErrorResumeWith(resume);
 
         Subscriber<String> subscriber = TestHelper.mockSubscriber();
         flowable.subscribe(subscriber);
@@ -81,7 +81,7 @@ public String apply(String s) {
             }
         });
 
-        Flowable<String> flowable = w.onErrorResumeNext(resume);
+        Flowable<String> flowable = w.onErrorResumeWith(resume);
 
         Subscriber<String> subscriber = TestHelper.mockSubscriber();
 
@@ -114,7 +114,7 @@ public void subscribe(Subscriber<? super String> t1) {
 
         });
         Flowable<String> resume = Flowable.just("resume");
-        Flowable<String> flowable = testObservable.onErrorResumeNext(resume);
+        Flowable<String> flowable = testObservable.onErrorResumeWith(resume);
 
         Subscriber<String> subscriber = TestHelper.mockSubscriber();
         flowable.subscribe(subscriber);
@@ -136,7 +136,7 @@ public void subscribe(Subscriber<? super String> t1) {
 
         });
         Flowable<String> resume = Flowable.just("resume");
-        Flowable<String> flowable = testObservable.subscribeOn(Schedulers.io()).onErrorResumeNext(resume);
+        Flowable<String> flowable = testObservable.subscribeOn(Schedulers.io()).onErrorResumeWith(resume);
 
         Subscriber<String> subscriber = TestHelper.mockSubscriber();
         TestSubscriber<String> ts = new TestSubscriber<String>(subscriber, Long.MAX_VALUE);
@@ -196,7 +196,7 @@ public void run() {
     public void backpressure() {
         TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
         Flowable.range(0, 100000)
-                .onErrorResumeNext(Flowable.just(1))
+                .onErrorResumeWith(Flowable.just(1))
                 .observeOn(Schedulers.computation())
                 .map(new Function<Integer, Integer>() {
                     int c;
@@ -226,7 +226,7 @@ public void normalBackpressure() {
 
         PublishProcessor<Integer> pp = PublishProcessor.create();
 
-        pp.onErrorResumeNext(Flowable.range(3, 2)).subscribe(ts);
+        pp.onErrorResumeWith(Flowable.range(3, 2)).subscribe(ts);
 
         ts.request(2);
 
diff --git a/src/test/java/io/reactivex/internal/operators/flowable/FlowablePublishFunctionTest.java b/src/test/java/io/reactivex/internal/operators/flowable/FlowablePublishFunctionTest.java
@@ -326,7 +326,7 @@ public void errorResubscribe() {
         .publish(new Function<Flowable<Object>, Publisher<Object>>() {
             @Override
             public Publisher<Object> apply(Flowable<Object> f) throws Exception {
-                return f.onErrorResumeNext(f);
+                return f.onErrorResumeWith(f);
             }
         })
         .test()
diff --git a/src/test/java/io/reactivex/internal/operators/maybe/MaybeOnErrorXTest.java b/src/test/java/io/reactivex/internal/operators/maybe/MaybeOnErrorXTest.java
@@ -193,23 +193,23 @@ public MaybeSource<Object> apply(Maybe<Object> v) throws Exception {
 
     @Test
     public void onErrorNextDispose() {
-        TestHelper.checkDisposed(PublishProcessor.create().singleElement().onErrorResumeNext(Maybe.just(1)));
+        TestHelper.checkDisposed(PublishProcessor.create().singleElement().onErrorResumeWith(Maybe.just(1)));
     }
 
     @Test
     public void onErrorNextDoubleOnSubscribe() {
         TestHelper.checkDoubleOnSubscribeMaybe(new Function<Maybe<Object>, MaybeSource<Object>>() {
             @Override
             public MaybeSource<Object> apply(Maybe<Object> v) throws Exception {
-                return v.onErrorResumeNext(Maybe.just(1));
+                return v.onErrorResumeWith(Maybe.just(1));
             }
         });
     }
 
     @Test
     public void onErrorNextIsAlsoError() {
         Maybe.error(new TestException("Main"))
-        .onErrorResumeNext(Maybe.error(new TestException("Secondary")))
+        .onErrorResumeWith(Maybe.error(new TestException("Secondary")))
         .to(TestHelper.testConsumer())
         .assertFailureAndMessage(TestException.class, "Secondary");
     }
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableDelayTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableDelayTest.java
@@ -876,7 +876,7 @@ public void accept(Throwable throwable) throws Exception {
                         latch.countDown();
                     }
                 })
-                .onErrorResumeNext(Observable.<String>empty())
+                .onErrorResumeWith(Observable.<String>empty())
                 .subscribe();
 
         latch.await();
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableOnErrorResumeNextTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableOnErrorResumeNextTest.java
@@ -32,7 +32,7 @@
 import io.reactivex.schedulers.Schedulers;
 import io.reactivex.testsupport.*;
 
-public class ObservableOnErrorResumeNextViaFunctionTest {
+public class ObservableOnErrorResumeNextTest {
 
     @Test
     public void resumeNextWithSynchronousExecution() {
diff --git a/src/test/java/io/reactivex/internal/operators/observable/ObservableOnErrorResumeWithTest.java b/src/test/java/io/reactivex/internal/operators/observable/ObservableOnErrorResumeWithTest.java
@@ -28,7 +28,7 @@
 import io.reactivex.schedulers.Schedulers;
 import io.reactivex.testsupport.TestHelper;
 
-public class ObservableOnErrorResumeNextViaObservableTest {
+public class ObservableOnErrorResumeWithTest {
 
     @Test
     public void resumeNext() {
@@ -37,7 +37,7 @@ public void resumeNext() {
         TestObservable f = new TestObservable(upstream, "one", "fail", "two", "three");
         Observable<String> w = Observable.unsafeCreate(f);
         Observable<String> resume = Observable.just("twoResume", "threeResume");
-        Observable<String> observable = w.onErrorResumeNext(resume);
+        Observable<String> observable = w.onErrorResumeWith(resume);
 
         Observer<String> observer = TestHelper.mockObserver();
         observable.subscribe(observer);
@@ -79,7 +79,7 @@ public String apply(String s) {
             }
         });
 
-        Observable<String> observable = w.onErrorResumeNext(resume);
+        Observable<String> observable = w.onErrorResumeWith(resume);
 
         Observer<String> observer = TestHelper.mockObserver();
 
@@ -112,7 +112,7 @@ public void subscribe(Observer<? super String> t1) {
 
         });
         Observable<String> resume = Observable.just("resume");
-        Observable<String> observable = testObservable.onErrorResumeNext(resume);
+        Observable<String> observable = testObservable.onErrorResumeWith(resume);
 
         Observer<String> observer = TestHelper.mockObserver();
         observable.subscribe(observer);
@@ -134,7 +134,7 @@ public void subscribe(Observer<? super String> t1) {
 
         });
         Observable<String> resume = Observable.just("resume");
-        Observable<String> observable = testObservable.subscribeOn(Schedulers.io()).onErrorResumeNext(resume);
+        Observable<String> observable = testObservable.subscribeOn(Schedulers.io()).onErrorResumeWith(resume);
 
         Observer<String> observer = TestHelper.mockObserver();
         TestObserver<String> to = new TestObserver<String>(observer);
@@ -194,7 +194,7 @@ public void run() {
     public void backpressure() {
         TestObserver<Integer> to = new TestObserver<Integer>();
         Observable.range(0, 100000)
-                .onErrorResumeNext(Observable.just(1))
+                .onErrorResumeWith(Observable.just(1))
                 .observeOn(Schedulers.computation())
                 .map(new Function<Integer, Integer>() {
                     int c;
diff --git a/src/test/java/io/reactivex/internal/operators/single/SingleDelayTest.java b/src/test/java/io/reactivex/internal/operators/single/SingleDelayTest.java
@@ -149,7 +149,7 @@ public void accept(Throwable throwable) throws Exception {
                         latch.countDown();
                     }
                 })
-                .onErrorResumeNext(Single.just(""))
+                .onErrorResumeWith(Single.just(""))
                 .subscribe();
 
         latch.await();
diff --git a/src/test/java/io/reactivex/internal/operators/single/SingleMiscTest.java b/src/test/java/io/reactivex/internal/operators/single/SingleMiscTest.java
@@ -106,9 +106,9 @@ public void hide() {
     }
 
     @Test
-    public void onErrorResumeNext() {
+    public void onErrorResumeWith() {
         Single.<Integer>error(new TestException())
-        .onErrorResumeNext(Single.just(1))
+        .onErrorResumeWith(Single.just(1))
         .test()
         .assertResult(1);
     }
diff --git a/src/test/java/io/reactivex/internal/operators/single/SingleOnErrorXTest.java b/src/test/java/io/reactivex/internal/operators/single/SingleOnErrorXTest.java
@@ -53,31 +53,31 @@ public Integer apply(Throwable e) throws Exception {
     @Test
     public void resumeErrors() {
         Single.error(new TestException("Main"))
-        .onErrorResumeNext(Single.error(new TestException("Resume")))
+        .onErrorResumeWith(Single.error(new TestException("Resume")))
         .to(TestHelper.<Object>testConsumer())
         .assertFailureAndMessage(TestException.class, "Resume");
     }
 
     @Test
     public void resumeDispose() {
         TestHelper.checkDisposed(Single.error(new TestException("Main"))
-        .onErrorResumeNext(Single.just(1)));
+        .onErrorResumeWith(Single.just(1)));
     }
 
     @Test
     public void resumeDoubleOnSubscribe() {
         TestHelper.checkDoubleOnSubscribeSingle(new Function<Single<Object>, SingleSource<Object>>() {
             @Override
             public SingleSource<Object> apply(Single<Object> s) throws Exception {
-                return s.onErrorResumeNext(Single.just(1));
+                return s.onErrorResumeWith(Single.just(1));
             }
         });
     }
 
     @Test
     public void resumeSuccess() {
         Single.just(1)
-        .onErrorResumeNext(Single.just(2))
+        .onErrorResumeWith(Single.just(2))
         .test()
         .assertResult(1);
     }
diff --git a/src/test/java/io/reactivex/maybe/MaybeTest.java b/src/test/java/io/reactivex/maybe/MaybeTest.java
diff --git a/src/test/java/io/reactivex/observable/ObservableNullTests.java b/src/test/java/io/reactivex/observable/ObservableNullTests.java
diff --git a/src/test/java/io/reactivex/single/SingleNullTests.java b/src/test/java/io/reactivex/single/SingleNullTests.java
diff --git a/src/test/java/io/reactivex/tck/OnErrorResumeWithTckTest.java b/src/test/java/io/reactivex/tck/OnErrorResumeWithTckTest.java

Original file line number	Diff line number	Diff line change
`@@ -1646,8 +1646,8 @@ public void onBackpressureDropActionNull() {`
`1646`	`1646`	`}`
`1647`	`1647`
`1648`	`1648`	`@Test(expected = NullPointerException.class)`
`1649`		`- public void onErrorResumeNextFunctionNull() {`
`1650`		`- just1.onErrorResumeNext((Function<Throwable, Publisher<Integer>>)null);`
	`1649`	`+ public void onErrorResumeNextNull() {`
	`1650`	`+ just1.onErrorResumeNext(null);`
`1651`	`1651`	`}`
`1652`	`1652`
`1653`	`1653`	`@Test`
`@@ -1669,8 +1669,8 @@ public Publisher<Object> apply(Throwable e) {`
`1669`	`1669`	`}`
`1670`	`1670`
`1671`	`1671`	`@Test(expected = NullPointerException.class)`
`1672`		`- public void onErrorResumeNextPublisherNull() {`
`1673`		`- just1.onErrorResumeNext((Publisher<Integer>)null);`
	`1672`	`+ public void onErrorResumeWithNull() {`
	`1673`	`+ just1.onErrorResumeWith(null);`
`1674`	`1674`	`}`
`1675`	`1675`
`1676`	`1676`	`@Test(expected = NullPointerException.class)`
`@@ -2958,11 +2958,6 @@ public void sampleFlowableNull() {`
`2958`	`2958`	`just1.sample(null);`
`2959`	`2959`	`}`
`2960`	`2960`
`2961`		`- @Test(expected = NullPointerException.class)`
`2962`		`- public void onErrorResumeNextFlowableNull() {`
`2963`		`- just1.onErrorResumeNext((Flowable<Integer>)null);`
`2964`		`- }`
`2965`		`-`
`2966`	`2961`	`@SuppressWarnings("unchecked")`
`2967`	`2962`	`@Test(expected = NullPointerException.class)`
`2968`	`2963`	`public void combineLatestDelayErrorVarargsFunctionReturnsNull() {`
Original file line number	Diff line number	Diff line change
`@@ -928,7 +928,7 @@ public void accept(Throwable throwable) throws Exception {`
`928`	`928`	`latch.countDown();`
`929`	`929`	`}`
`930`	`930`	`})`
`931`		`- .onErrorResumeNext(Flowable.<String>empty())`
	`931`	`+ .onErrorResumeWith(Flowable.<String>empty())`
`932`	`932`	`.subscribe();`
`933`	`933`
`934`	`934`	`latch.await();`
Original file line number	Diff line number	Diff line change
`@@ -326,7 +326,7 @@ public void errorResubscribe() {`
`326`	`326`	`.publish(new Function<Flowable<Object>, Publisher<Object>>() {`
`327`	`327`	`@Override`
`328`	`328`	`public Publisher<Object> apply(Flowable<Object> f) throws Exception {`
`329`		`- return f.onErrorResumeNext(f);`
	`329`	`+ return f.onErrorResumeWith(f);`
`330`	`330`	`}`
`331`	`331`	`})`
`332`	`332`	`.test()`
Original file line number	Diff line number	Diff line change
`@@ -193,23 +193,23 @@ public MaybeSource<Object> apply(Maybe<Object> v) throws Exception {`
`193`	`193`
`194`	`194`	`@Test`
`195`	`195`	`public void onErrorNextDispose() {`
`196`		`- TestHelper.checkDisposed(PublishProcessor.create().singleElement().onErrorResumeNext(Maybe.just(1)));`
	`196`	`+ TestHelper.checkDisposed(PublishProcessor.create().singleElement().onErrorResumeWith(Maybe.just(1)));`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`@Test`
`200`	`200`	`public void onErrorNextDoubleOnSubscribe() {`
`201`	`201`	`TestHelper.checkDoubleOnSubscribeMaybe(new Function<Maybe<Object>, MaybeSource<Object>>() {`
`202`	`202`	`@Override`
`203`	`203`	`public MaybeSource<Object> apply(Maybe<Object> v) throws Exception {`
`204`		`- return v.onErrorResumeNext(Maybe.just(1));`
	`204`	`+ return v.onErrorResumeWith(Maybe.just(1));`
`205`	`205`	`}`
`206`	`206`	`});`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`@Test`
`210`	`210`	`public void onErrorNextIsAlsoError() {`
`211`	`211`	`Maybe.error(new TestException("Main"))`
`212`		`- .onErrorResumeNext(Maybe.error(new TestException("Secondary")))`
	`212`	`+ .onErrorResumeWith(Maybe.error(new TestException("Secondary")))`
`213`	`213`	`.to(TestHelper.testConsumer())`
`214`	`214`	`.assertFailureAndMessage(TestException.class, "Secondary");`
`215`	`215`	`}`
Original file line number	Diff line number	Diff line change
`@@ -876,7 +876,7 @@ public void accept(Throwable throwable) throws Exception {`
`876`	`876`	`latch.countDown();`
`877`	`877`	`}`
`878`	`878`	`})`
`879`		`- .onErrorResumeNext(Observable.<String>empty())`
	`879`	`+ .onErrorResumeWith(Observable.<String>empty())`
`880`	`880`	`.subscribe();`
`881`	`881`
`882`	`882`	`latch.await();`