Debian Codegraph @

src/test/java/io/reactivex/rxjava3/core/TransformerTest.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.core;
15
16 import static org.junit.Assert.*;
17
18 import org.junit.Test;
19 import org.reactivestreams.Publisher;
20
21 import io.reactivex.rxjava3.core.ConverterTest.*;
22 import io.reactivex.rxjava3.exceptions.TestException;
23
24 public class TransformerTest extends RxJavaTest {
25
26 @Test
27 public void flowableTransformerThrows() {
28 try {
29 Flowable.just(1).compose(new FlowableTransformer<Integer, Integer>() {
30 @Override
31 public Publisher<Integer> apply(Flowable<Integer> v) {
32 throw new TestException("Forced failure");
33 }
34 });
35 fail("Should have thrown!");
36 } catch (TestException ex) {
37 assertEquals("Forced failure", ex.getMessage());
38 }
39 }
40
41 @Test
42 public void observableTransformerThrows() {
43 try {
44 Observable.just(1).compose(new ObservableTransformer<Integer, Integer>() {
45 @Override
46 public Observable<Integer> apply(Observable<Integer> v) {
47 throw new TestException("Forced failure");
48 }
49 });
50 fail("Should have thrown!");
51 } catch (TestException ex) {
52 assertEquals("Forced failure", ex.getMessage());
53 }
54 }
55
56 @Test
57 public void singleTransformerThrows() {
58 try {
59 Single.just(1).compose(new SingleTransformer<Integer, Integer>() {
60 @Override
61 public Single<Integer> apply(Single<Integer> v) {
62 throw new TestException("Forced failure");
63 }
64 });
65 fail("Should have thrown!");
66 } catch (TestException ex) {
67 assertEquals("Forced failure", ex.getMessage());
68 }
69 }
70
71 @Test
72 public void maybeTransformerThrows() {
73 try {
74 Maybe.just(1).compose(new MaybeTransformer<Integer, Integer>() {
75 @Override
76 public Maybe<Integer> apply(Maybe<Integer> v) {
77 throw new TestException("Forced failure");
78 }
79 });
80 fail("Should have thrown!");
81 } catch (TestException ex) {
82 assertEquals("Forced failure", ex.getMessage());
83 }
84 }
85
86 @Test
87 public void completableTransformerThrows() {
88 try {
89 Completable.complete().compose(new CompletableTransformer() {
90 @Override
91 public Completable apply(Completable v) {
92 throw new TestException("Forced failure");
93 }
94 });
95 fail("Should have thrown!");
96 } catch (TestException ex) {
97 assertEquals("Forced failure", ex.getMessage());
98 }
99 }
100
101 // Test demos for signature generics in compose() methods. Just needs to compile.
102
103 @Test
104 public void observableGenericsSignatureTest() {
105 A<String, Integer> a = new A<String, Integer>() { };
106
107 Observable.just(a).compose(TransformerTest.<String>testObservableTransformerCreator());
108 }
109
110 @Test
111 public void singleGenericsSignatureTest() {
112 A<String, Integer> a = new A<String, Integer>() { };
113
114 Single.just(a).compose(TransformerTest.<String>testSingleTransformerCreator());
115 }
116
117 @Test
118 public void maybeGenericsSignatureTest() {
119 A<String, Integer> a = new A<String, Integer>() { };
120
121 Maybe.just(a).compose(TransformerTest.<String>testMaybeTransformerCreator());
122 }
123
124 @Test
125 public void flowableGenericsSignatureTest() {
126 A<String, Integer> a = new A<String, Integer>() { };
127
128 Flowable.just(a).compose(TransformerTest.<String>testFlowableTransformerCreator());
129 }
130
131 private static <T> ObservableTransformer<A<T, ?>, B<T>> testObservableTransformerCreator() {
132 return new ObservableTransformer<A<T, ?>, B<T>>() {
133 @Override
134 public ObservableSource<B<T>> apply(Observable<A<T, ?>> a) {
135 return Observable.empty();
136 }
137 };
138 }
139
140 private static <T> SingleTransformer<A<T, ?>, B<T>> testSingleTransformerCreator() {
141 return new SingleTransformer<A<T, ?>, B<T>>() {
142 @Override
143 public SingleSource<B<T>> apply(Single<A<T, ?>> a) {
144 return Single.never();
145 }
146 };
147 }
148
149 private static <T> MaybeTransformer<A<T, ?>, B<T>> testMaybeTransformerCreator() {
150 return new MaybeTransformer<A<T, ?>, B<T>>() {
151 @Override
152 public MaybeSource<B<T>> apply(Maybe<A<T, ?>> a) {
153 return Maybe.empty();
154 }
155 };
156 }
157
158 private static <T> FlowableTransformer<A<T, ?>, B<T>> testFlowableTransformerCreator() {
159 return new FlowableTransformer<A<T, ?>, B<T>>() {
160 @Override
161 public Publisher<B<T>> apply(Flowable<A<T, ?>> a) {
162 return Flowable.empty();
163 }
164 };
165 }
166 }