Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/observers/QueueDrainObserverTest.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.observers;
15
16 import org.junit.Test;
17
18 import io.reactivex.rxjava3.core.*;
19 import io.reactivex.rxjava3.disposables.*;
20 import io.reactivex.rxjava3.observers.TestObserver;
21 import io.reactivex.rxjava3.operators.SpscArrayQueue;
22 import io.reactivex.rxjava3.testsupport.TestHelper;
23
24 public class QueueDrainObserverTest extends RxJavaTest {
25
26 static final QueueDrainObserver<Integer, Integer, Integer> createUnordered(TestObserver<Integer> to, final Disposable d) {
27 return new QueueDrainObserver<Integer, Integer, Integer>(to, new SpscArrayQueue<>(4)) {
28 @Override
29 public void onNext(Integer t) {
30 fastPathEmit(t, false, d);
31 }
32
33 @Override
34 public void onError(Throwable t) {
35 }
36
37 @Override
38 public void onComplete() {
39 }
40
41 @Override
42 public void onSubscribe(Disposable d) {
43 }
44
45 @Override
46 public void accept(Observer<? super Integer> a, Integer v) {
47 super.accept(a, v);
48 a.onNext(v);
49 }
50 };
51 }
52
53 static final QueueDrainObserver<Integer, Integer, Integer> createOrdered(TestObserver<Integer> to, final Disposable d) {
54 return new QueueDrainObserver<Integer, Integer, Integer>(to, new SpscArrayQueue<>(4)) {
55 @Override
56 public void onNext(Integer t) {
57 fastPathOrderedEmit(t, false, d);
58 }
59
60 @Override
61 public void onError(Throwable t) {
62 }
63
64 @Override
65 public void onComplete() {
66 }
67
68 @Override
69 public void onSubscribe(Disposable d) {
70 }
71
72 @Override
73 public void accept(Observer<? super Integer> a, Integer v) {
74 super.accept(a, v);
75 a.onNext(v);
76 }
77 };
78 }
79
80 @Test
81 public void unorderedSlowPath() {
82 TestObserver<Integer> to = new TestObserver<>();
83 Disposable d = Disposable.empty();
84 QueueDrainObserver<Integer, Integer, Integer> qd = createUnordered(to, d);
85 to.onSubscribe(Disposable.empty());
86
87 qd.enter();
88 qd.onNext(1);
89
90 to.assertEmpty();
91 }
92
93 @Test
94 public void orderedSlowPath() {
95 TestObserver<Integer> to = new TestObserver<>();
96 Disposable d = Disposable.empty();
97 QueueDrainObserver<Integer, Integer, Integer> qd = createOrdered(to, d);
98 to.onSubscribe(Disposable.empty());
99
100 qd.enter();
101 qd.onNext(1);
102
103 to.assertEmpty();
104 }
105
106 @Test
107 public void orderedSlowPathNonEmptyQueue() {
108 TestObserver<Integer> to = new TestObserver<>();
109 Disposable d = Disposable.empty();
110 QueueDrainObserver<Integer, Integer, Integer> qd = createOrdered(to, d);
111 to.onSubscribe(Disposable.empty());
112
113 qd.queue.offer(0);
114 qd.onNext(1);
115
116 to.assertValuesOnly(0, 1);
117 }
118
119 @Test
120 public void unorderedOnNextRace() {
121 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
122
123 TestObserver<Integer> to = new TestObserver<>();
124 Disposable d = Disposable.empty();
125 final QueueDrainObserver<Integer, Integer, Integer> qd = createUnordered(to, d);
126 to.onSubscribe(Disposable.empty());
127
128 Runnable r1 = new Runnable() {
129 @Override
130 public void run() {
131 qd.onNext(1);
132 }
133 };
134
135 TestHelper.race(r1, r1);
136
137 to.assertValuesOnly(1, 1);
138 }
139 }
140
141 @Test
142 public void orderedOnNextRace() {
143 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
144
145 TestObserver<Integer> to = new TestObserver<>();
146 Disposable d = Disposable.empty();
147 final QueueDrainObserver<Integer, Integer, Integer> qd = createOrdered(to, d);
148 to.onSubscribe(Disposable.empty());
149
150 Runnable r1 = new Runnable() {
151 @Override
152 public void run() {
153 qd.onNext(1);
154 }
155 };
156
157 TestHelper.race(r1, r1);
158
159 to.assertValuesOnly(1, 1);
160 }
161 }
162
163 }