Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleDoAfterSuccessTest.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.single;
15
16 import static org.junit.Assert.*;
17
18 import java.util.*;
19
20 import org.junit.Test;
21
22 import io.reactivex.rxjava3.core.*;
23 import io.reactivex.rxjava3.exceptions.TestException;
24 import io.reactivex.rxjava3.functions.*;
25 import io.reactivex.rxjava3.internal.functions.Functions;
26 import io.reactivex.rxjava3.observers.TestObserver;
27 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
28 import io.reactivex.rxjava3.subjects.PublishSubject;
29 import io.reactivex.rxjava3.testsupport.TestHelper;
30
31 public class SingleDoAfterSuccessTest extends RxJavaTest {
32
33 final List<Integer> values = new ArrayList<>();
34
35 final Consumer<Integer> afterSuccess = new Consumer<Integer>() {
36 @Override
37 public void accept(Integer e) throws Exception {
38 values.add(-e);
39 }
40 };
41
42 final TestObserver<Integer> to = new TestObserver<Integer>() {
43 @Override
44 public void onNext(Integer t) {
45 super.onNext(t);
46 SingleDoAfterSuccessTest.this.values.add(t);
47 }
48 };
49
50 @Test
51 public void just() {
52 Single.just(1)
53 .doAfterSuccess(afterSuccess)
54 .subscribeWith(to)
55 .assertResult(1);
56
57 assertEquals(Arrays.asList(1, -1), values);
58 }
59
60 @Test
61 public void error() {
62 Single.<Integer>error(new TestException())
63 .doAfterSuccess(afterSuccess)
64 .subscribeWith(to)
65 .assertFailure(TestException.class);
66
67 assertTrue(values.isEmpty());
68 }
69
70 @Test
71 public void justConditional() {
72 Single.just(1)
73 .doAfterSuccess(afterSuccess)
74 .filter(Functions.alwaysTrue())
75 .subscribeWith(to)
76 .assertResult(1);
77
78 assertEquals(Arrays.asList(1, -1), values);
79 }
80
81 @Test
82 public void errorConditional() {
83 Single.<Integer>error(new TestException())
84 .doAfterSuccess(afterSuccess)
85 .filter(Functions.alwaysTrue())
86 .subscribeWith(to)
87 .assertFailure(TestException.class);
88
89 assertTrue(values.isEmpty());
90 }
91
92 @Test
93 public void consumerThrows() {
94 List<Throwable> errors = TestHelper.trackPluginErrors();
95 try {
96 Single.just(1)
97 .doAfterSuccess(new Consumer<Integer>() {
98 @Override
99 public void accept(Integer e) throws Exception {
100 throw new TestException();
101 }
102 })
103 .test()
104 .assertResult(1);
105
106 TestHelper.assertUndeliverable(errors, 0, TestException.class);
107 } finally {
108 RxJavaPlugins.reset();
109 }
110 }
111
112 @Test
113 public void dispose() {
114 TestHelper.checkDisposed(PublishSubject.<Integer>create().singleOrError().doAfterSuccess(afterSuccess));
115 }
116
117 @Test
118 public void doubleOnSubscribe() {
119 TestHelper.checkDoubleOnSubscribeSingle(new Function<Single<Integer>, SingleSource<Integer>>() {
120 @Override
121 public SingleSource<Integer> apply(Single<Integer> m) throws Exception {
122 return m.doAfterSuccess(afterSuccess);
123 }
124 });
125 }
126 }