Skip to content

Commit b99efbf

Browse files
ggikkoakarnokd
ggikko
authored and
akarnokd
committed
2.x : Rename variable name "subject" to "processor" for exact expression (#5721)
1 parent 205375d commit b99efbf

7 files changed

+211
-211
lines changed

‎src/test/java/io/reactivex/processors/AsyncProcessorTest.java

Lines changed: 57 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -46,14 +46,14 @@ protected FlowableProcessor<Object> create() {
4646

4747
@Test
4848
public void testNeverCompleted() {
49-
AsyncProcessor<String> subject = AsyncProcessor.create();
49+
AsyncProcessor<String> processor = AsyncProcessor.create();
5050

5151
Subscriber<String> observer = TestHelper.mockSubscriber();
52-
subject.subscribe(observer);
52+
processor.subscribe(observer);
5353

54-
subject.onNext("one");
55-
subject.onNext("two");
56-
subject.onNext("three");
54+
processor.onNext("one");
55+
processor.onNext("two");
56+
processor.onNext("three");
5757

5858
verify(observer, Mockito.never()).onNext(anyString());
5959
verify(observer, Mockito.never()).onError(testException);
@@ -62,15 +62,15 @@ public void testNeverCompleted() {
6262

6363
@Test
6464
public void testCompleted() {
65-
AsyncProcessor<String> subject = AsyncProcessor.create();
65+
AsyncProcessor<String> processor = AsyncProcessor.create();
6666

6767
Subscriber<String> observer = TestHelper.mockSubscriber();
68-
subject.subscribe(observer);
68+
processor.subscribe(observer);
6969

70-
subject.onNext("one");
71-
subject.onNext("two");
72-
subject.onNext("three");
73-
subject.onComplete();
70+
processor.onNext("one");
71+
processor.onNext("two");
72+
processor.onNext("three");
73+
processor.onComplete();
7474

7575
verify(observer, times(1)).onNext("three");
7676
verify(observer, Mockito.never()).onError(any(Throwable.class));
@@ -80,13 +80,13 @@ public void testCompleted() {
8080
@Test
8181
@Ignore("Null values not allowed")
8282
public void testNull() {
83-
AsyncProcessor<String> subject = AsyncProcessor.create();
83+
AsyncProcessor<String> processor = AsyncProcessor.create();
8484

8585
Subscriber<String> observer = TestHelper.mockSubscriber();
86-
subject.subscribe(observer);
86+
processor.subscribe(observer);
8787

88-
subject.onNext(null);
89-
subject.onComplete();
88+
processor.onNext(null);
89+
processor.onComplete();
9090

9191
verify(observer, times(1)).onNext(null);
9292
verify(observer, Mockito.never()).onError(any(Throwable.class));
@@ -95,16 +95,16 @@ public void testNull() {
9595

9696
@Test
9797
public void testSubscribeAfterCompleted() {
98-
AsyncProcessor<String> subject = AsyncProcessor.create();
98+
AsyncProcessor<String> processor = AsyncProcessor.create();
9999

100100
Subscriber<String> observer = TestHelper.mockSubscriber();
101101

102-
subject.onNext("one");
103-
subject.onNext("two");
104-
subject.onNext("three");
105-
subject.onComplete();
102+
processor.onNext("one");
103+
processor.onNext("two");
104+
processor.onNext("three");
105+
processor.onComplete();
106106

107-
subject.subscribe(observer);
107+
processor.subscribe(observer);
108108

109109
verify(observer, times(1)).onNext("three");
110110
verify(observer, Mockito.never()).onError(any(Throwable.class));
@@ -113,18 +113,18 @@ public void testSubscribeAfterCompleted() {
113113

114114
@Test
115115
public void testSubscribeAfterError() {
116-
AsyncProcessor<String> subject = AsyncProcessor.create();
116+
AsyncProcessor<String> processor = AsyncProcessor.create();
117117

118118
Subscriber<String> observer = TestHelper.mockSubscriber();
119119

120-
subject.onNext("one");
121-
subject.onNext("two");
122-
subject.onNext("three");
120+
processor.onNext("one");
121+
processor.onNext("two");
122+
processor.onNext("three");
123123

124124
RuntimeException re = new RuntimeException("failed");
125-
subject.onError(re);
125+
processor.onError(re);
126126

127-
subject.subscribe(observer);
127+
processor.subscribe(observer);
128128

129129
verify(observer, times(1)).onError(re);
130130
verify(observer, Mockito.never()).onNext(any(String.class));
@@ -133,18 +133,18 @@ public void testSubscribeAfterError() {
133133

134134
@Test
135135
public void testError() {
136-
AsyncProcessor<String> subject = AsyncProcessor.create();
136+
AsyncProcessor<String> processor = AsyncProcessor.create();
137137

138138
Subscriber<String> observer = TestHelper.mockSubscriber();
139-
subject.subscribe(observer);
139+
processor.subscribe(observer);
140140

141-
subject.onNext("one");
142-
subject.onNext("two");
143-
subject.onNext("three");
144-
subject.onError(testException);
145-
subject.onNext("four");
146-
subject.onError(new Throwable());
147-
subject.onComplete();
141+
processor.onNext("one");
142+
processor.onNext("two");
143+
processor.onNext("three");
144+
processor.onError(testException);
145+
processor.onNext("four");
146+
processor.onError(new Throwable());
147+
processor.onComplete();
148148

149149
verify(observer, Mockito.never()).onNext(anyString());
150150
verify(observer, times(1)).onError(testException);
@@ -153,23 +153,23 @@ public void testError() {
153153

154154
@Test
155155
public void testUnsubscribeBeforeCompleted() {
156-
AsyncProcessor<String> subject = AsyncProcessor.create();
156+
AsyncProcessor<String> processor = AsyncProcessor.create();
157157

158158
Subscriber<String> observer = TestHelper.mockSubscriber();
159159
TestSubscriber<String> ts = new TestSubscriber<String>(observer);
160-
subject.subscribe(ts);
160+
processor.subscribe(ts);
161161

162-
subject.onNext("one");
163-
subject.onNext("two");
162+
processor.onNext("one");
163+
processor.onNext("two");
164164

165165
ts.dispose();
166166

167167
verify(observer, Mockito.never()).onNext(anyString());
168168
verify(observer, Mockito.never()).onError(any(Throwable.class));
169169
verify(observer, Mockito.never()).onComplete();
170170

171-
subject.onNext("three");
172-
subject.onComplete();
171+
processor.onNext("three");
172+
processor.onComplete();
173173

174174
verify(observer, Mockito.never()).onNext(anyString());
175175
verify(observer, Mockito.never()).onError(any(Throwable.class));
@@ -178,12 +178,12 @@ public void testUnsubscribeBeforeCompleted() {
178178

179179
@Test
180180
public void testEmptySubjectCompleted() {
181-
AsyncProcessor<String> subject = AsyncProcessor.create();
181+
AsyncProcessor<String> processor = AsyncProcessor.create();
182182

183183
Subscriber<String> observer = TestHelper.mockSubscriber();
184-
subject.subscribe(observer);
184+
processor.subscribe(observer);
185185

186-
subject.onComplete();
186+
processor.onComplete();
187187

188188
InOrder inOrder = inOrder(observer);
189189
inOrder.verify(observer, never()).onNext(null);
@@ -204,10 +204,10 @@ public void testSubscribeCompletionRaceCondition() {
204204
* With the synchronization code in place I can not get this to fail on my laptop.
205205
*/
206206
for (int i = 0; i < 50; i++) {
207-
final AsyncProcessor<String> subject = AsyncProcessor.create();
207+
final AsyncProcessor<String> processor = AsyncProcessor.create();
208208
final AtomicReference<String> value1 = new AtomicReference<String>();
209209

210-
subject.subscribe(new Consumer<String>() {
210+
processor.subscribe(new Consumer<String>() {
211211

212212
@Override
213213
public void accept(String t1) {
@@ -226,15 +226,15 @@ public void accept(String t1) {
226226

227227
@Override
228228
public void run() {
229-
subject.onNext("value");
230-
subject.onComplete();
229+
processor.onNext("value");
230+
processor.onComplete();
231231
}
232232
});
233233

234-
SubjectSubscriberThread t2 = new SubjectSubscriberThread(subject);
235-
SubjectSubscriberThread t3 = new SubjectSubscriberThread(subject);
236-
SubjectSubscriberThread t4 = new SubjectSubscriberThread(subject);
237-
SubjectSubscriberThread t5 = new SubjectSubscriberThread(subject);
234+
SubjectSubscriberThread t2 = new SubjectSubscriberThread(processor);
235+
SubjectSubscriberThread t3 = new SubjectSubscriberThread(processor);
236+
SubjectSubscriberThread t4 = new SubjectSubscriberThread(processor);
237+
SubjectSubscriberThread t5 = new SubjectSubscriberThread(processor);
238238

239239
t2.start();
240240
t3.start();
@@ -262,18 +262,18 @@ public void run() {
262262

263263
private static class SubjectSubscriberThread extends Thread {
264264

265-
private final AsyncProcessor<String> subject;
265+
private final AsyncProcessor<String> processor;
266266
private final AtomicReference<String> value = new AtomicReference<String>();
267267

268-
SubjectSubscriberThread(AsyncProcessor<String> subject) {
269-
this.subject = subject;
268+
SubjectSubscriberThread(AsyncProcessor<String> processor) {
269+
this.processor = processor;
270270
}
271271

272272
@Override
273273
public void run() {
274274
try {
275275
// a timeout exception will happen if we don't get a terminal state
276-
String v = subject.timeout(2000, TimeUnit.MILLISECONDS).blockingSingle();
276+
String v = processor.timeout(2000, TimeUnit.MILLISECONDS).blockingSingle();
277277
value.set(v);
278278
} catch (Exception e) {
279279
e.printStackTrace();

0 commit comments

Comments
 (0)