Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableOnErrorResumeWithTest.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.internal.operators.observable;
15
16 import static org.junit.Assert.fail;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.util.concurrent.TimeUnit;
21
22 import org.junit.Test;
23 import org.mockito.Mockito;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.disposables.Disposable;
27 import io.reactivex.rxjava3.functions.Function;
28 import io.reactivex.rxjava3.observers.TestObserver;
29 import io.reactivex.rxjava3.schedulers.Schedulers;
30 import io.reactivex.rxjava3.testsupport.TestHelper;
31
32 public class ObservableOnErrorResumeWithTest extends RxJavaTest {
33
34 @Test
35 public void resumeNext() {
36 Disposable upstream = mock(Disposable.class);
37 // Trigger failure on second element
38 TestObservable f = new TestObservable(upstream, "one", "fail", "two", "three");
39 Observable<String> w = Observable.unsafeCreate(f);
40 Observable<String> resume = Observable.just("twoResume", "threeResume");
41 Observable<String> observable = w.onErrorResumeWith(resume);
42
43 Observer<String> observer = TestHelper.mockObserver();
44 observable.subscribe(observer);
45
46 try {
47 f.t.join();
48 } catch (InterruptedException e) {
49 fail(e.getMessage());
50 }
51
52 verify(observer, Mockito.never()).onError(any(Throwable.class));
53 verify(observer, times(1)).onComplete();
54 verify(observer, times(1)).onNext("one");
55 verify(observer, Mockito.never()).onNext("two");
56 verify(observer, Mockito.never()).onNext("three");
57 verify(observer, times(1)).onNext("twoResume");
58 verify(observer, times(1)).onNext("threeResume");
59 }
60
61 @Test
62 public void mapResumeAsyncNext() {
63 Disposable sr = mock(Disposable.class);
64 // Trigger multiple failures
65 Observable<String> w = Observable.just("one", "fail", "two", "three", "fail");
66 // Resume Observable is async
67 TestObservable f = new TestObservable(sr, "twoResume", "threeResume");
68 Observable<String> resume = Observable.unsafeCreate(f);
69
70 // Introduce map function that fails intermittently (Map does not prevent this when the Observer is a
71 // rx.operator incl onErrorResumeNextViaObservable)
72 w = w.map(new Function<String, String>() {
73 @Override
74 public String apply(String s) {
75 if ("fail".equals(s)) {
76 throw new RuntimeException("Forced Failure");
77 }
78 System.out.println("BadMapper:" + s);
79 return s;
80 }
81 });
82
83 Observable<String> observable = w.onErrorResumeWith(resume);
84
85 Observer<String> observer = TestHelper.mockObserver();
86
87 observable.subscribe(observer);
88
89 try {
90 f.t.join();
91 } catch (InterruptedException e) {
92 fail(e.getMessage());
93 }
94
95 verify(observer, Mockito.never()).onError(any(Throwable.class));
96 verify(observer, times(1)).onComplete();
97 verify(observer, times(1)).onNext("one");
98 verify(observer, Mockito.never()).onNext("two");
99 verify(observer, Mockito.never()).onNext("three");
100 verify(observer, times(1)).onNext("twoResume");
101 verify(observer, times(1)).onNext("threeResume");
102 }
103
104 static class TestObservable implements ObservableSource<String> {
105
106 final Disposable upstream;
107 final String[] values;
108 Thread t;
109
110 TestObservable(Disposable upstream, String... values) {
111 this.upstream = upstream;
112 this.values = values;
113 }
114
115 @Override
116 public void subscribe(final Observer<? super String> observer) {
117 System.out.println("TestObservable subscribed to ...");
118 observer.onSubscribe(upstream);
119 t = new Thread(new Runnable() {
120
121 @Override
122 public void run() {
123 try {
124 System.out.println("running TestObservable thread");
125 for (String s : values) {
126 if ("fail".equals(s)) {
127 throw new RuntimeException("Forced Failure");
128 }
129 System.out.println("TestObservable onNext: " + s);
130 observer.onNext(s);
131 }
132 System.out.println("TestObservable onComplete");
133 observer.onComplete();
134 } catch (Throwable e) {
135 System.out.println("TestObservable onError: " + e);
136 observer.onError(e);
137 }
138 }
139
140 });
141 System.out.println("starting TestObservable thread");
142 t.start();
143 System.out.println("done starting TestObservable thread");
144 }
145 }
146
147 @Test
148 public void backpressure() {
149 TestObserver<Integer> to = new TestObserver<>();
150 Observable.range(0, 100000)
151 .onErrorResumeWith(Observable.just(1))
152 .observeOn(Schedulers.computation())
153 .map(new Function<Integer, Integer>() {
154 int c;
155
156 @Override
157 public Integer apply(Integer t1) {
158 if (c++ <= 1) {
159 // slow
160 try {
161 Thread.sleep(500);
162 } catch (InterruptedException e) {
163 e.printStackTrace();
164 }
165 }
166 return t1;
167 }
168
169 })
170 .subscribe(to);
171 to.awaitDone(5, TimeUnit.SECONDS);
172 to.assertNoErrors();
173 }
174 }