Debian Codegraph @

src/test/java/io/reactivex/rxjava3/schedulers/CachedThreadSchedulerTest.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.schedulers;
15
16 import static org.junit.Assert.*;
17
18 import java.util.concurrent.TimeUnit;
19
20 import org.junit.Test;
21
22 import io.reactivex.rxjava3.core.*;
23 import io.reactivex.rxjava3.core.Scheduler.Worker;
24 import io.reactivex.rxjava3.disposables.*;
25 import io.reactivex.rxjava3.functions.*;
26 import io.reactivex.rxjava3.internal.schedulers.IoScheduler;
27 import io.reactivex.rxjava3.testsupport.SuppressUndeliverable;
28
29 public class CachedThreadSchedulerTest extends AbstractSchedulerConcurrencyTests {
30
31 @Override
32 protected Scheduler getScheduler() {
33 return Schedulers.io();
34 }
35
36 /**
37 * IO scheduler defaults to using CachedThreadScheduler.
38 */
39 @Test
40 public final void iOScheduler() {
41
42 Flowable<Integer> f1 = Flowable.just(1, 2, 3, 4, 5);
43 Flowable<Integer> f2 = Flowable.just(6, 7, 8, 9, 10);
44 Flowable<String> f = Flowable.merge(f1, f2).map(new Function<Integer, String>() {
45
46 @Override
47 public String apply(Integer t) {
48 assertTrue(Thread.currentThread().getName().startsWith("RxCachedThreadScheduler"));
49 return "Value_" + t + "_Thread_" + Thread.currentThread().getName();
50 }
51 });
52
53 f.subscribeOn(Schedulers.io()).blockingForEach(new Consumer<String>() {
54
55 @Override
56 public void accept(String t) {
57 System.out.println("t: " + t);
58 }
59 });
60 }
61
62 @Test
63 public final void handledErrorIsNotDeliveredToThreadHandler() throws InterruptedException {
64 SchedulerTestHelper.handledErrorIsNotDeliveredToThreadHandler(getScheduler());
65 }
66
67 @Test
68 public void cancelledTaskRetention() throws InterruptedException {
69 Worker w = Schedulers.io().createWorker();
70 try {
71 ExecutorSchedulerTest.cancelledRetention(w, false);
72 } finally {
73 w.dispose();
74 }
75 w = Schedulers.io().createWorker();
76 try {
77 ExecutorSchedulerTest.cancelledRetention(w, true);
78 } finally {
79 w.dispose();
80 }
81 }
82
83 @Test
84 public void workerDisposed() {
85 Worker w = Schedulers.io().createWorker();
86
87 assertFalse(((Disposable)w).isDisposed());
88
89 w.dispose();
90
91 assertTrue(((Disposable)w).isDisposed());
92 }
93
94 @Test
95 @SuppressUndeliverable
96 public void shutdownRejects() {
97 final int[] calls = { 0 };
98
99 Runnable r = new Runnable() {
100 @Override
101 public void run() {
102 calls[0]++;
103 }
104 };
105
106 IoScheduler s = new IoScheduler();
107 s.shutdown();
108 s.shutdown();
109
110 s.scheduleDirect(r);
111
112 s.scheduleDirect(r, 1, TimeUnit.SECONDS);
113
114 s.schedulePeriodicallyDirect(r, 1, 1, TimeUnit.SECONDS);
115
116 Worker w = s.createWorker();
117 w.dispose();
118
119 assertEquals(Disposable.disposed(), w.schedule(r));
120
121 assertEquals(Disposable.disposed(), w.schedule(r, 1, TimeUnit.SECONDS));
122
123 assertEquals(Disposable.disposed(), w.schedulePeriodically(r, 1, 1, TimeUnit.SECONDS));
124
125 assertEquals(0, calls[0]);
126 }
127 }