Debian Codegraph @

src/test/java/io/reactivex/rxjava3/flowable/FlowableBackpressureTests.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.flowable;
15
16 import static org.junit.Assert.*;
17
18 import java.util.List;
19 import java.util.concurrent.*;
20 import java.util.concurrent.atomic.*;
21
22 import org.junit.*;
23 import org.junit.rules.TestName;
24 import org.reactivestreams.*;
25
26 import io.reactivex.rxjava3.core.*;
27 import io.reactivex.rxjava3.exceptions.MissingBackpressureException;
28 import io.reactivex.rxjava3.functions.*;
29 import io.reactivex.rxjava3.internal.subscriptions.SubscriptionHelper;
30 import io.reactivex.rxjava3.internal.util.BackpressureHelper;
31 import io.reactivex.rxjava3.schedulers.Schedulers;
32 import io.reactivex.rxjava3.subscribers.*;
33
34 public class FlowableBackpressureTests extends RxJavaTest {
35
36 static final class FirehoseNoBackpressure extends AtomicBoolean implements Subscription {
37
38 private static final long serialVersionUID = -669931580197884015L;
39 final Subscriber<? super Integer> downstream;
40 final AtomicInteger counter;
41 volatile boolean cancelled;
42
43 private FirehoseNoBackpressure(AtomicInteger counter, Subscriber<? super Integer> s) {
44 this.counter = counter;
45 this.downstream = s;
46 }
47
48 @Override
49 public void request(long n) {
50 if (!SubscriptionHelper.validate(n)) {
51 return;
52 }
53 if (compareAndSet(false, true)) {
54 int i = 0;
55 final Subscriber<? super Integer> a = downstream;
56 final AtomicInteger c = counter;
57
58 while (!cancelled) {
59 a.onNext(i++);
60 c.incrementAndGet();
61 }
62 System.out.println("unsubscribed after: " + i);
63 }
64 }
65
66 @Override
67 public void cancel() {
68 cancelled = true;
69 }
70 }
71
72 @Rule
73 public TestName testName = new TestName();
74
75 @After
76 public void doAfterTest() {
77 // FIXME LATER
78 // TestObstructionDetection.checkObstruction();
79 }
80
81 @Test
82 public void observeOn() {
83 int num = (int) (Flowable.bufferSize() * 2.1);
84 AtomicInteger c = new AtomicInteger();
85 TestSubscriber<Integer> ts = new TestSubscriber<>();
86 incrementingIntegers(c).observeOn(Schedulers.computation()).take(num).subscribe(ts);
87 ts.awaitDone(5, TimeUnit.SECONDS);
88 ts.assertNoErrors();
89 System.out.println("testObserveOn => Received: " + ts.values().size() + " Emitted: " + c.get());
90 assertEquals(num, ts.values().size());
91 assertTrue(c.get() < Flowable.bufferSize() * 4);
92 }
93
94 @Test
95 public void observeOnWithSlowConsumer() {
96 int num = (int) (Flowable.bufferSize() * 0.2);
97 AtomicInteger c = new AtomicInteger();
98 TestSubscriber<Integer> ts = new TestSubscriber<>();
99 incrementingIntegers(c).observeOn(Schedulers.computation()).map(
100 new Function<Integer, Integer>() {
101 @Override
102 public Integer apply(Integer i) {
103 try {
104 Thread.sleep(1);
105 } catch (InterruptedException e) {
106 e.printStackTrace();
107 }
108 return i;
109 }
110 }
111 ).take(num).subscribe(ts);
112 ts.awaitDone(5, TimeUnit.SECONDS);
113 ts.assertNoErrors();
114 System.out.println("testObserveOnWithSlowConsumer => Received: " + ts.values().size() + " Emitted: " + c.get());
115 assertEquals(num, ts.values().size());
116 assertTrue(c.get() < Flowable.bufferSize() * 2);
117 }
118
119 @Test
120 public void mergeSync() {
121 int num = (int) (Flowable.bufferSize() * 4.1);
122 AtomicInteger c1 = new AtomicInteger();
123 AtomicInteger c2 = new AtomicInteger();
124 TestSubscriber<Integer> ts = new TestSubscriber<>();
125 Flowable<Integer> merged = Flowable.merge(incrementingIntegers(c1), incrementingIntegers(c2));
126
127 merged.take(num).subscribe(ts);
128 ts.awaitDone(5, TimeUnit.SECONDS);
129 ts.assertNoErrors();
130 System.out.println("Expected: " + num + " got: " + ts.values().size());
131 System.out.println("testMergeSync => Received: " + ts.values().size() + " Emitted: " + c1.get() + " / " + c2.get());
132 assertEquals(num, ts.values().size());
133 // either one can starve the other, but neither should be capable of doing more than 5 batches (taking 4.1)
134 // TODO is it possible to make this deterministic rather than one possibly starving the other?
135 // benjchristensen => In general I'd say it's not worth trying to make it so, as "fair" algoritms generally take a performance hit
136 assertTrue(c1.get() < Flowable.bufferSize() * 5);
137 assertTrue(c2.get() < Flowable.bufferSize() * 5);
138 }
139
140 @Test
141 public void mergeAsync() {
142 int num = (int) (Flowable.bufferSize() * 4.1);
143 AtomicInteger c1 = new AtomicInteger();
144 AtomicInteger c2 = new AtomicInteger();
145 TestSubscriber<Integer> ts = new TestSubscriber<>();
146 Flowable<Integer> merged = Flowable.merge(
147 incrementingIntegers(c1).subscribeOn(Schedulers.computation()),
148 incrementingIntegers(c2).subscribeOn(Schedulers.computation()));
149
150 merged.take(num).subscribe(ts);
151 ts.awaitDone(5, TimeUnit.SECONDS);
152 ts.assertNoErrors();
153 System.out.println("testMergeAsync => Received: " + ts.values().size() + " Emitted: " + c1.get() + " / " + c2.get());
154 assertEquals(num, ts.values().size());
155 // either one can starve the other, but neither should be capable of doing more than 5 batches (taking 4.1)
156 // TODO is it possible to make this deterministic rather than one possibly starving the other?
157 // benjchristensen => In general I'd say it's not worth trying to make it so, as "fair" algoritms generally take a performance hit
158 int max = Flowable.bufferSize() * 7;
159 assertTrue("" + c1.get() + " >= " + max, c1.get() < max);
160 assertTrue("" + c2.get() + " >= " + max, c2.get() < max);
161 }
162
163 @Test
164 public void mergeAsyncThenObserveOnLoop() {
165 for (int i = 0; i < 500; i++) {
166 if (i % 10 == 0) {
167 System.out.println("testMergeAsyncThenObserveOnLoop >> " + i);
168 }
169 // Verify there is no MissingBackpressureException
170 int num = (int) (Flowable.bufferSize() * 4.1);
171 AtomicInteger c1 = new AtomicInteger();
172 AtomicInteger c2 = new AtomicInteger();
173
174 TestSubscriber<Integer> ts = new TestSubscriber<>();
175 Flowable<Integer> merged = Flowable.merge(
176 incrementingIntegers(c1).subscribeOn(Schedulers.computation()),
177 incrementingIntegers(c2).subscribeOn(Schedulers.computation()));
178
179 merged
180 .observeOn(Schedulers.io())
181 .take(num)
182 .subscribe(ts);
183
184 ts.awaitDone(5, TimeUnit.SECONDS);
185 ts.assertComplete();
186 ts.assertNoErrors();
187 System.out.println("testMergeAsyncThenObserveOn => Received: " + ts.values().size() + " Emitted: " + c1.get() + " / " + c2.get());
188 assertEquals(num, ts.values().size());
189 }
190 }
191
192 @Test
193 public void mergeAsyncThenObserveOn() {
194 int num = (int) (Flowable.bufferSize() * 4.1);
195 AtomicInteger c1 = new AtomicInteger();
196 AtomicInteger c2 = new AtomicInteger();
197 TestSubscriber<Integer> ts = new TestSubscriber<>();
198 Flowable<Integer> merged = Flowable.merge(
199 incrementingIntegers(c1).subscribeOn(Schedulers.computation()),
200 incrementingIntegers(c2).subscribeOn(Schedulers.computation()));
201
202 merged.observeOn(Schedulers.newThread()).take(num).subscribe(ts);
203 ts.awaitDone(5, TimeUnit.SECONDS);
204 ts.assertNoErrors();
205 System.out.println("testMergeAsyncThenObserveOn => Received: " + ts.values().size() + " Emitted: " + c1.get() + " / " + c2.get());
206 assertEquals(num, ts.values().size());
207 // either one can starve the other, but neither should be capable of doing more than 5 batches (taking 4.1)
208 // TODO is it possible to make this deterministic rather than one possibly starving the other?
209 // benjchristensen => In general I'd say it's not worth trying to make it so, as "fair" algoritms generally take a performance hit
210 // akarnokd => run this in a loop over 10k times and never saw values get as high as 7*SIZE, but since observeOn delays the unsubscription non-deterministically, the test will remain unreliable
211 assertTrue(c1.get() < Flowable.bufferSize() * 7);
212 assertTrue(c2.get() < Flowable.bufferSize() * 7);
213 }
214
215 @Test
216 public void flatMapSync() {
217 int num = (int) (Flowable.bufferSize() * 2.1);
218 AtomicInteger c = new AtomicInteger();
219 TestSubscriber<Integer> ts = new TestSubscriber<>();
220
221 incrementingIntegers(c)
222 .flatMap(new Function<Integer, Publisher<Integer>>() {
223 @Override
224 public Publisher<Integer> apply(Integer i) {
225 return incrementingIntegers(new AtomicInteger()).take(10);
226 }
227 })
228 .take(num).subscribe(ts);
229
230 ts.awaitDone(5, TimeUnit.SECONDS);
231 ts.assertNoErrors();
232 System.out.println("testFlatMapSync => Received: " + ts.values().size() + " Emitted: " + c.get());
233 assertEquals(num, ts.values().size());
234 // expect less than 1 buffer since the flatMap is emitting 10 each time, so it is num/10 that will be taken.
235 assertTrue(c.get() < Flowable.bufferSize());
236 }
237
238 @Test
239 public void zipSync() {
240 int num = (int) (Flowable.bufferSize() * 4.1);
241 AtomicInteger c1 = new AtomicInteger();
242 AtomicInteger c2 = new AtomicInteger();
243 TestSubscriber<Integer> ts = new TestSubscriber<>();
244
245 Flowable<Integer> zipped = Flowable.zip(
246 incrementingIntegers(c1),
247 incrementingIntegers(c2),
248 new BiFunction<Integer, Integer, Integer>() {
249 @Override
250 public Integer apply(Integer t1, Integer t2) {
251 return t1 + t2;
252 }
253 });
254
255 zipped.take(num)
256 .subscribe(ts);
257
258 ts.awaitDone(5, TimeUnit.SECONDS);
259 ts.assertNoErrors();
260 System.out.println("testZipSync => Received: " + ts.values().size() + " Emitted: " + c1.get() + " / " + c2.get());
261 assertEquals(num, ts.values().size());
262 assertTrue(c1.get() < Flowable.bufferSize() * 7);
263 assertTrue(c2.get() < Flowable.bufferSize() * 7);
264 }
265
266 @Test
267 public void zipAsync() {
268 int num = (int) (Flowable.bufferSize() * 2.1);
269 AtomicInteger c1 = new AtomicInteger();
270 AtomicInteger c2 = new AtomicInteger();
271 TestSubscriber<Integer> ts = new TestSubscriber<>();
272 Flowable<Integer> zipped = Flowable.zip(
273 incrementingIntegers(c1).subscribeOn(Schedulers.computation()),
274 incrementingIntegers(c2).subscribeOn(Schedulers.computation()),
275 new BiFunction<Integer, Integer, Integer>() {
276 @Override
277 public Integer apply(Integer t1, Integer t2) {
278 return t1 + t2;
279 }
280 });
281
282 zipped.take(num).subscribe(ts);
283 ts.awaitDone(5, TimeUnit.SECONDS);
284 ts.assertNoErrors();
285 System.out.println("testZipAsync => Received: " + ts.values().size() + " Emitted: " + c1.get() + " / " + c2.get());
286 assertEquals(num, ts.values().size());
287 int max = Flowable.bufferSize() * 5;
288 assertTrue("" + c1.get() + " >= " + max, c1.get() < max);
289 assertTrue("" + c2.get() + " >= " + max, c2.get() < max);
290 }
291
292 @Test
293 public void subscribeOnScheduling() {
294 // in a loop for repeating the concurrency in this to increase chance of failure
295 for (int i = 0; i < 100; i++) {
296 int num = (int) (Flowable.bufferSize() * 2.1);
297 AtomicInteger c = new AtomicInteger();
298 ConcurrentLinkedQueue<Thread> threads = new ConcurrentLinkedQueue<>();
299 TestSubscriber<Integer> ts = new TestSubscriber<>();
300 // observeOn is there to make it async and need backpressure
301 incrementingIntegers(c, threads).subscribeOn(Schedulers.computation()).observeOn(Schedulers.computation()).take(num).subscribe(ts);
302 ts.awaitDone(5, TimeUnit.SECONDS);
303 ts.assertNoErrors();
304 System.out.println("testSubscribeOnScheduling => Received: " + ts.values().size() + " Emitted: " + c.get());
305 assertEquals(num, ts.values().size());
306 assertTrue(c.get() < Flowable.bufferSize() * 4);
307 Thread first = null;
308 for (Thread t : threads) {
309 System.out.println("testSubscribeOnScheduling => thread: " + t);
310 if (first == null) {
311 first = t;
312 } else {
313 if (!first.equals(t)) {
314 fail("Expected to see the same thread");
315 }
316 }
317 }
318 System.out.println("testSubscribeOnScheduling => Number of batch requests seen: " + threads.size());
319 assertTrue(threads.size() > 1);
320 System.out.println("-------------------------------------------------------------------------------------------");
321 }
322 }
323
324 @Test
325 public void takeFilterSkipChainAsync() {
326 int num = (int) (Flowable.bufferSize() * 2.1);
327 AtomicInteger c = new AtomicInteger();
328 TestSubscriber<Integer> ts = new TestSubscriber<>();
329 incrementingIntegers(c).observeOn(Schedulers.computation())
330 .skip(10000)
331 .filter(new Predicate<Integer>() {
332 @Override
333 public boolean test(Integer i) {
334 return i > 11000;
335 }
336 }).take(num).subscribe(ts);
337
338 ts.awaitDone(5, TimeUnit.SECONDS);
339 ts.assertNoErrors();
340
341 // emit 10000 that are skipped
342 // emit next 1000 that are filtered out
343 // take num
344 // so emitted is at least 10000+1000+num + extra for buffer size/threshold
345 int expected = 10000 + 1000 + Flowable.bufferSize() * 3 + Flowable.bufferSize() / 2;
346
347 System.out.println("testTakeFilterSkipChain => Received: " + ts.values().size() + " Emitted: " + c.get() + " Expected: " + expected);
348 assertEquals(num, ts.values().size());
349 assertTrue(c.get() < expected);
350 }
351
352 @Test
353 public void userSubscriberUsingRequestSync() {
354 AtomicInteger c = new AtomicInteger();
355 final AtomicInteger totalReceived = new AtomicInteger();
356 final AtomicInteger batches = new AtomicInteger();
357 final AtomicInteger received = new AtomicInteger();
358 incrementingIntegers(c).subscribe(new ResourceSubscriber<Integer>() {
359
360 @Override
361 public void onStart() {
362 request(100);
363 }
364
365 @Override
366 public void onComplete() {
367
368 }
369
370 @Override
371 public void onError(Throwable e) {
372
373 }
374
375 @Override
376 public void onNext(Integer t) {
377 int total = totalReceived.incrementAndGet();
378 received.incrementAndGet();
379 if (total >= 2000) {
380 dispose();
381 }
382 if (received.get() == 100) {
383 batches.incrementAndGet();
384 request(100);
385 received.set(0);
386 }
387 }
388
389 });
390
391 System.out.println("testUserSubscriberUsingRequestSync => Received: " + totalReceived.get() + " Emitted: " + c.get() + " Request Batches: " + batches.get());
392 assertEquals(2000, c.get());
393 assertEquals(2000, totalReceived.get());
394 assertEquals(20, batches.get());
395 }
396
397 @Test
398 public void userSubscriberUsingRequestAsync() throws InterruptedException {
399 AtomicInteger c = new AtomicInteger();
400 final AtomicInteger totalReceived = new AtomicInteger();
401 final AtomicInteger received = new AtomicInteger();
402 final AtomicInteger batches = new AtomicInteger();
403 final CountDownLatch latch = new CountDownLatch(1);
404 incrementingIntegers(c).subscribeOn(Schedulers.newThread()).subscribe(
405 new ResourceSubscriber<Integer>() {
406
407 @Override
408 public void onStart() {
409 request(100);
410 }
411
412 @Override
413 public void onComplete() {
414 latch.countDown();
415 }
416
417 @Override
418 public void onError(Throwable e) {
419 latch.countDown();
420 }
421
422 @Override
423 public void onNext(Integer t) {
424 int total = totalReceived.incrementAndGet();
425 received.incrementAndGet();
426 boolean done = false;
427 if (total >= 2000) {
428 done = true;
429 dispose();
430 }
431 if (received.get() == 100) {
432 batches.incrementAndGet();
433 received.set(0);
434 if (!done) {
435 request(100);
436 }
437 }
438 if (done) {
439 latch.countDown();
440 }
441 }
442
443 });
444
445 latch.await();
446 System.out.println("testUserSubscriberUsingRequestAsync => Received: " + totalReceived.get() + " Emitted: " + c.get() + " Request Batches: " + batches.get());
447 assertEquals(2000, c.get());
448 assertEquals(2000, totalReceived.get());
449 assertEquals(20, batches.get());
450 }
451
452 @Test
453 public void firehoseFailsAsExpected() {
454 AtomicInteger c = new AtomicInteger();
455 TestSubscriber<Integer> ts = new TestSubscriber<>();
456
457 firehose(c).observeOn(Schedulers.computation())
458 .map(new Function<Integer, Integer>() {
459 @Override
460 public Integer apply(Integer v) {
461 try {
462 Thread.sleep(10);
463 } catch (Exception e) {
464 e.printStackTrace();
465 }
466 return v;
467 }
468 })
469 .subscribe(ts);
470
471 ts.awaitDone(5, TimeUnit.SECONDS);
472 System.out.println("testFirehoseFailsAsExpected => Received: " + ts.values().size() + " Emitted: " + c.get());
473
474 // FIXME it is possible slow is not slow enough or the main gets delayed and thus more than one source value is emitted.
475 int vc = ts.values().size();
476 assertTrue("10 < " + vc, vc <= 10);
477
478 ts.assertError(MissingBackpressureException.class);
479 }
480
481 @Test
482 public void firehoseFailsAsExpectedLoop() {
483 for (int i = 0; i < 100; i++) {
484 firehoseFailsAsExpected();
485 }
486 }
487
488 @Test
489 public void onBackpressureDrop() {
490 long t = System.currentTimeMillis();
491 for (int i = 0; i < 100; i++) {
492 // stop the test if we are getting close to the timeout because slow machines
493 // may not get through 100 iterations
494 if (System.currentTimeMillis() - t > TimeUnit.SECONDS.toMillis(9)) {
495 break;
496 }
497 int num = (int) (Flowable.bufferSize() * 1.1); // > 1 so that take doesn't prevent buffer overflow
498 AtomicInteger c = new AtomicInteger();
499 TestSubscriber<Integer> ts = new TestSubscriber<>();
500 firehose(c).onBackpressureDrop()
501 .observeOn(Schedulers.computation())
502 .map(SLOW_PASS_THRU).take(num).subscribe(ts);
503 ts.awaitDone(5, TimeUnit.SECONDS);
504 ts.assertNoErrors();
505
506 List<Integer> onNextEvents = ts.values();
507 assertEquals(num, onNextEvents.size());
508
509 Integer lastEvent = onNextEvents.get(num - 1);
510
511 System.out.println("testOnBackpressureDrop => Received: " + onNextEvents.size() + " Emitted: " + c.get() + " Last value: " + lastEvent);
512 // it drop, so we should get some number far higher than what would have sequentially incremented
513 assertTrue(num - 1 <= lastEvent.intValue());
514 }
515 }
516
517 @Test
518 public void onBackpressureDropWithAction() {
519 for (int i = 0; i < 100; i++) {
520 final AtomicInteger emitCount = new AtomicInteger();
521 final AtomicInteger dropCount = new AtomicInteger();
522 final AtomicInteger passCount = new AtomicInteger();
523 final int num = Flowable.bufferSize() * 3; // > 1 so that take doesn't prevent buffer overflow
524 TestSubscriber<Integer> ts = new TestSubscriber<>();
525
526 firehose(emitCount)
527 .onBackpressureDrop(new Consumer<Integer>() {
528 @Override
529 public void accept(Integer v) {
530 dropCount.incrementAndGet();
531 }
532 })
533 .doOnNext(new Consumer<Integer>() {
534 @Override
535 public void accept(Integer v) {
536 passCount.incrementAndGet();
537 }
538 })
539 .observeOn(Schedulers.computation())
540 .map(SLOW_PASS_THRU)
541 .take(num).subscribe(ts);
542
543 ts.awaitDone(5, TimeUnit.SECONDS);
544 ts.assertNoErrors();
545
546 List<Integer> onNextEvents = ts.values();
547 Integer lastEvent = onNextEvents.get(num - 1);
548 System.out.println(testName.getMethodName() + " => Received: " + onNextEvents.size() + " Passed: " + passCount.get() + " Dropped: " + dropCount.get() + " Emitted: " + emitCount.get() + " Last value: " + lastEvent);
549 assertEquals(num, onNextEvents.size());
550 // in reality, num < passCount
551 assertTrue(num <= passCount.get());
552 // it drop, so we should get some number far higher than what would have sequentially incremented
553 assertTrue(num - 1 <= lastEvent.intValue());
554 assertTrue(0 < dropCount.get());
555 assertEquals(emitCount.get(), passCount.get() + dropCount.get());
556 }
557 }
558
559 @Test
560 public void onBackpressureDropSynchronous() {
561 for (int i = 0; i < 100; i++) {
562 int num = (int) (Flowable.bufferSize() * 1.1); // > 1 so that take doesn't prevent buffer overflow
563 AtomicInteger c = new AtomicInteger();
564 TestSubscriber<Integer> ts = new TestSubscriber<>();
565 firehose(c).onBackpressureDrop()
566 .map(SLOW_PASS_THRU).take(num).subscribe(ts);
567 ts.awaitDone(5, TimeUnit.SECONDS);
568 ts.assertNoErrors();
569
570 List<Integer> onNextEvents = ts.values();
571 assertEquals(num, onNextEvents.size());
572
573 Integer lastEvent = onNextEvents.get(num - 1);
574
575 System.out.println("testOnBackpressureDrop => Received: " + onNextEvents.size() + " Emitted: " + c.get() + " Last value: " + lastEvent);
576 // it drop, so we should get some number far higher than what would have sequentially incremented
577 assertTrue(num - 1 <= lastEvent.intValue());
578 }
579 }
580
581 @Test
582 public void onBackpressureDropSynchronousWithAction() {
583 for (int i = 0; i < 100; i++) {
584 final AtomicInteger dropCount = new AtomicInteger();
585 int num = (int) (Flowable.bufferSize() * 1.1); // > 1 so that take doesn't prevent buffer overflow
586 AtomicInteger c = new AtomicInteger();
587 TestSubscriber<Integer> ts = new TestSubscriber<>();
588 firehose(c).onBackpressureDrop(new Consumer<Integer>() {
589 @Override
590 public void accept(Integer j) {
591 dropCount.incrementAndGet();
592 }
593 })
594 .map(SLOW_PASS_THRU).take(num).subscribe(ts);
595 ts.awaitDone(5, TimeUnit.SECONDS);
596 ts.assertNoErrors();
597
598 List<Integer> onNextEvents = ts.values();
599 assertEquals(num, onNextEvents.size());
600
601 Integer lastEvent = onNextEvents.get(num - 1);
602
603 System.out.println("testOnBackpressureDrop => Received: " + onNextEvents.size() + " Dropped: " + dropCount.get() + " Emitted: " + c.get() + " Last value: " + lastEvent);
604 // it drop, so we should get some number far higher than what would have sequentially incremented
605 assertTrue(num - 1 <= lastEvent.intValue());
606 // no drop in synchronous mode
607 assertEquals(0, dropCount.get());
608 assertEquals(c.get(), onNextEvents.size());
609 }
610 }
611
612 @Test
613 public void onBackpressureBuffer() {
614 int num = (int) (Flowable.bufferSize() * 1.1); // > 1 so that take doesn't prevent buffer overflow
615 AtomicInteger c = new AtomicInteger();
616 TestSubscriber<Integer> ts = new TestSubscriber<>();
617
618 firehose(c).takeWhile(new Predicate<Integer>() {
619 @Override
620 public boolean test(Integer t1) {
621 return t1 < 100000;
622 }
623 })
624 .onBackpressureBuffer()
625 .observeOn(Schedulers.computation())
626 .map(SLOW_PASS_THRU).take(num).subscribe(ts);
627
628 ts.awaitDone(5, TimeUnit.SECONDS);
629 ts.assertNoErrors();
630 System.out.println("testOnBackpressureBuffer => Received: " + ts.values().size() + " Emitted: " + c.get());
631 assertEquals(num, ts.values().size());
632 // it buffers, so we should get the right value sequentially
633 assertEquals(num - 1, ts.values().get(num - 1).intValue());
634 }
635
636 /**
637 * A synchronous Flowable that will emit incrementing integers as requested.
638 *
639 * @param counter the shared value to be incremented
640 * @return the incrementing Flowable instance
641 */
642 private static Flowable<Integer> incrementingIntegers(final AtomicInteger counter) {
643 return incrementingIntegers(counter, null);
644 }
645
646 private static Flowable<Integer> incrementingIntegers(final AtomicInteger counter, final ConcurrentLinkedQueue<Thread> threadsSeen) {
647 return Flowable.unsafeCreate(new Publisher<Integer>() {
648
649 @Override
650 public void subscribe(final Subscriber<? super Integer> s) {
651 s.onSubscribe(new Subscription() {
652 int i;
653
654 volatile boolean cancelled;
655
656 final AtomicLong requested = new AtomicLong();
657
658 @Override
659 public void request(long n) {
660 if (!SubscriptionHelper.validate(n)) {
661 return;
662 }
663 if (threadsSeen != null) {
664 threadsSeen.offer(Thread.currentThread());
665 }
666 long c = BackpressureHelper.add(requested, n);
667 if (c == 0) {
668 while (!cancelled) {
669 counter.incrementAndGet();
670 s.onNext(i++);
671 if (requested.decrementAndGet() == 0) {
672 // we're done emitting the number requested so return
673 return;
674 }
675 }
676 }
677 }
678
679 @Override
680 public void cancel() {
681 cancelled = true;
682 }
683 });
684 }
685
686 });
687 }
688
689 /**
690 * Incrementing int without backpressure.
691 *
692 * @param counter the shared value to increment
693 * @return the Flowable doing the increments
694 */
695 private static Flowable<Integer> firehose(final AtomicInteger counter) {
696 return Flowable.unsafeCreate(new Publisher<Integer>() {
697 @Override
698 public void subscribe(Subscriber<? super Integer> s) {
699 Subscription s2 = new FirehoseNoBackpressure(counter, s);
700 s.onSubscribe(s2);
701 }
702 });
703 }
704
705 static final Function<Integer, Integer> SLOW_PASS_THRU = new Function<Integer, Integer>() {
706 volatile int sink;
707 @Override
708 public Integer apply(Integer t1) {
709 // be slow ... but faster than Thread.sleep(1)
710 String t = "";
711 int s = sink;
712 for (int i = 2000; i >= 0; i--) {
713 t = String.valueOf(i + t.hashCode() + s);
714 }
715 sink = t.hashCode();
716 return t1;
717 }
718
719 };
720 }