73 }
74 }
75
76 /**
77 * A newCachedThreadPool with given ThreadFactory can execute runnables
78 */
79 public void testNewCachedThreadPool2() {
80 final ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
81 try (PoolCleaner cleaner = cleaner(e)) {
82 e.execute(new NoOpRunnable());
83 e.execute(new NoOpRunnable());
84 e.execute(new NoOpRunnable());
85 }
86 }
87
88 /**
89 * A newCachedThreadPool with null ThreadFactory throws NPE
90 */
91 public void testNewCachedThreadPool3() {
92 try {
93 ExecutorService e = Executors.newCachedThreadPool(null);
94 shouldThrow();
95 } catch (NullPointerException success) {}
96 }
97
98 /**
99 * A new SingleThreadExecutor can execute runnables
100 */
101 public void testNewSingleThreadExecutor1() {
102 final ExecutorService e = Executors.newSingleThreadExecutor();
103 try (PoolCleaner cleaner = cleaner(e)) {
104 e.execute(new NoOpRunnable());
105 e.execute(new NoOpRunnable());
106 e.execute(new NoOpRunnable());
107 }
108 }
109
110 /**
111 * A new SingleThreadExecutor with given ThreadFactory can execute runnables
112 */
113 public void testNewSingleThreadExecutor2() {
114 final ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
115 try (PoolCleaner cleaner = cleaner(e)) {
116 e.execute(new NoOpRunnable());
117 e.execute(new NoOpRunnable());
118 e.execute(new NoOpRunnable());
119 }
120 }
121
122 /**
123 * A new SingleThreadExecutor with null ThreadFactory throws NPE
124 */
125 public void testNewSingleThreadExecutor3() {
126 try {
127 ExecutorService e = Executors.newSingleThreadExecutor(null);
128 shouldThrow();
129 } catch (NullPointerException success) {}
130 }
131
132 /**
133 * A new SingleThreadExecutor cannot be casted to concrete implementation
134 */
135 public void testCastNewSingleThreadExecutor() {
136 final ExecutorService e = Executors.newSingleThreadExecutor();
137 try (PoolCleaner cleaner = cleaner(e)) {
138 try {
139 ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
140 shouldThrow();
141 } catch (ClassCastException success) {}
142 }
143 }
144
145 /**
146 * A new newFixedThreadPool can execute runnables
147 */
155 }
156
157 /**
158 * A new newFixedThreadPool with given ThreadFactory can execute runnables
159 */
160 public void testNewFixedThreadPool2() {
161 final ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
162 try (PoolCleaner cleaner = cleaner(e)) {
163 e.execute(new NoOpRunnable());
164 e.execute(new NoOpRunnable());
165 e.execute(new NoOpRunnable());
166 }
167 }
168
169 /**
170 * A new newFixedThreadPool with null ThreadFactory throws
171 * NullPointerException
172 */
173 public void testNewFixedThreadPool3() {
174 try {
175 ExecutorService e = Executors.newFixedThreadPool(2, null);
176 shouldThrow();
177 } catch (NullPointerException success) {}
178 }
179
180 /**
181 * A new newFixedThreadPool with 0 threads throws IllegalArgumentException
182 */
183 public void testNewFixedThreadPool4() {
184 try {
185 ExecutorService e = Executors.newFixedThreadPool(0);
186 shouldThrow();
187 } catch (IllegalArgumentException success) {}
188 }
189
190 /**
191 * An unconfigurable newFixedThreadPool can execute runnables
192 */
193 public void testUnconfigurableExecutorService() {
194 final ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
195 try (PoolCleaner cleaner = cleaner(e)) {
196 e.execute(new NoOpRunnable());
197 e.execute(new NoOpRunnable());
198 e.execute(new NoOpRunnable());
199 }
200 }
201
202 /**
203 * unconfigurableExecutorService(null) throws NPE
204 */
205 public void testUnconfigurableExecutorServiceNPE() {
206 try {
207 ExecutorService e = Executors.unconfigurableExecutorService(null);
208 shouldThrow();
209 } catch (NullPointerException success) {}
210 }
211
212 /**
213 * unconfigurableScheduledExecutorService(null) throws NPE
214 */
215 public void testUnconfigurableScheduledExecutorServiceNPE() {
216 try {
217 ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
218 shouldThrow();
219 } catch (NullPointerException success) {}
220 }
221
222 /**
223 * a newSingleThreadScheduledExecutor successfully runs delayed task
224 */
225 public void testNewSingleThreadScheduledExecutor() throws Exception {
226 final ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor();
227 try (PoolCleaner cleaner = cleaner(p)) {
228 final CountDownLatch proceed = new CountDownLatch(1);
229 final Runnable task = new CheckedRunnable() {
230 public void realRun() {
231 await(proceed);
232 }};
233 long startTime = System.nanoTime();
234 Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
235 timeoutMillis(), MILLISECONDS);
236 assertFalse(f.isDone());
237 proceed.countDown();
287 proceed.countDown();
288 assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
289 assertSame(Boolean.TRUE, f.get());
290 assertTrue(f.isDone());
291 assertFalse(f.isCancelled());
292 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
293 }
294 }
295
296 /**
297 * Future.get on submitted tasks will time out if they compute too long.
298 */
299 public void testTimedCallable() throws Exception {
300 final ExecutorService[] executors = {
301 Executors.newSingleThreadExecutor(),
302 Executors.newCachedThreadPool(),
303 Executors.newFixedThreadPool(2),
304 Executors.newScheduledThreadPool(2),
305 };
306
307 final Runnable sleeper = new CheckedInterruptedRunnable() {
308 public void realRun() throws InterruptedException {
309 delay(LONG_DELAY_MS);
310 }};
311
312 List<Thread> threads = new ArrayList<>();
313 for (final ExecutorService executor : executors) {
314 threads.add(newStartedThread(new CheckedRunnable() {
315 public void realRun() {
316 Future future = executor.submit(sleeper);
317 assertFutureTimesOut(future);
318 }}));
319 }
320 for (Thread thread : threads)
321 awaitTermination(thread);
322 for (ExecutorService executor : executors)
323 joinPool(executor);
324 }
325
326 /**
327 * ThreadPoolExecutor using defaultThreadFactory has
328 * specified group, priority, daemon status, and name
329 */
330 public void testDefaultThreadFactory() throws Exception {
331 final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
332 final CountDownLatch done = new CountDownLatch(1);
333 Runnable r = new CheckedRunnable() {
334 public void realRun() {
335 try {
336 Thread current = Thread.currentThread();
337 assertFalse(current.isDaemon());
338 assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
339 SecurityManager s = System.getSecurityManager();
340 assertSame(current.getThreadGroup(),
341 (s == null) ? egroup : s.getThreadGroup());
561 public void testCallable3() throws Exception {
562 Callable c = Executors.callable(new PrivilegedAction() {
563 public Object run() { return one; }});
564 assertSame(one, c.call());
565 }
566
567 /**
568 * callable(PrivilegedExceptionAction) returns its result when called
569 */
570 public void testCallable4() throws Exception {
571 Callable c = Executors.callable(new PrivilegedExceptionAction() {
572 public Object run() { return one; }});
573 assertSame(one, c.call());
574 }
575
576 /**
577 * callable(null Runnable) throws NPE
578 */
579 public void testCallableNPE1() {
580 try {
581 Callable c = Executors.callable((Runnable) null);
582 shouldThrow();
583 } catch (NullPointerException success) {}
584 }
585
586 /**
587 * callable(null, result) throws NPE
588 */
589 public void testCallableNPE2() {
590 try {
591 Callable c = Executors.callable((Runnable) null, one);
592 shouldThrow();
593 } catch (NullPointerException success) {}
594 }
595
596 /**
597 * callable(null PrivilegedAction) throws NPE
598 */
599 public void testCallableNPE3() {
600 try {
601 Callable c = Executors.callable((PrivilegedAction) null);
602 shouldThrow();
603 } catch (NullPointerException success) {}
604 }
605
606 /**
607 * callable(null PrivilegedExceptionAction) throws NPE
608 */
609 public void testCallableNPE4() {
610 try {
611 Callable c = Executors.callable((PrivilegedExceptionAction) null);
612 shouldThrow();
613 } catch (NullPointerException success) {}
614 }
615
616 /**
617 * callable(runnable, x).toString() contains toString of wrapped task
618 */
619 public void testCallable_withResult_toString() {
620 if (testImplementationDetails) {
621 Runnable r = () -> {};
622 Callable<String> c = Executors.callable(r, "");
623 assertEquals(
624 identityString(c) + "[Wrapped task = " + r.toString() + "]",
625 c.toString());
626 }
627 }
628
629 /**
630 * callable(runnable).toString() contains toString of wrapped task
631 */
|
73 }
74 }
75
76 /**
77 * A newCachedThreadPool with given ThreadFactory can execute runnables
78 */
79 public void testNewCachedThreadPool2() {
80 final ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
81 try (PoolCleaner cleaner = cleaner(e)) {
82 e.execute(new NoOpRunnable());
83 e.execute(new NoOpRunnable());
84 e.execute(new NoOpRunnable());
85 }
86 }
87
88 /**
89 * A newCachedThreadPool with null ThreadFactory throws NPE
90 */
91 public void testNewCachedThreadPool3() {
92 try {
93 ExecutorService unused = Executors.newCachedThreadPool(null);
94 shouldThrow();
95 } catch (NullPointerException success) {}
96 }
97
98 /**
99 * A new SingleThreadExecutor can execute runnables
100 */
101 public void testNewSingleThreadExecutor1() {
102 final ExecutorService e = Executors.newSingleThreadExecutor();
103 try (PoolCleaner cleaner = cleaner(e)) {
104 e.execute(new NoOpRunnable());
105 e.execute(new NoOpRunnable());
106 e.execute(new NoOpRunnable());
107 }
108 }
109
110 /**
111 * A new SingleThreadExecutor with given ThreadFactory can execute runnables
112 */
113 public void testNewSingleThreadExecutor2() {
114 final ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
115 try (PoolCleaner cleaner = cleaner(e)) {
116 e.execute(new NoOpRunnable());
117 e.execute(new NoOpRunnable());
118 e.execute(new NoOpRunnable());
119 }
120 }
121
122 /**
123 * A new SingleThreadExecutor with null ThreadFactory throws NPE
124 */
125 public void testNewSingleThreadExecutor3() {
126 try {
127 ExecutorService unused = Executors.newSingleThreadExecutor(null);
128 shouldThrow();
129 } catch (NullPointerException success) {}
130 }
131
132 /**
133 * A new SingleThreadExecutor cannot be casted to concrete implementation
134 */
135 public void testCastNewSingleThreadExecutor() {
136 final ExecutorService e = Executors.newSingleThreadExecutor();
137 try (PoolCleaner cleaner = cleaner(e)) {
138 try {
139 ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
140 shouldThrow();
141 } catch (ClassCastException success) {}
142 }
143 }
144
145 /**
146 * A new newFixedThreadPool can execute runnables
147 */
155 }
156
157 /**
158 * A new newFixedThreadPool with given ThreadFactory can execute runnables
159 */
160 public void testNewFixedThreadPool2() {
161 final ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
162 try (PoolCleaner cleaner = cleaner(e)) {
163 e.execute(new NoOpRunnable());
164 e.execute(new NoOpRunnable());
165 e.execute(new NoOpRunnable());
166 }
167 }
168
169 /**
170 * A new newFixedThreadPool with null ThreadFactory throws
171 * NullPointerException
172 */
173 public void testNewFixedThreadPool3() {
174 try {
175 ExecutorService unused = Executors.newFixedThreadPool(2, null);
176 shouldThrow();
177 } catch (NullPointerException success) {}
178 }
179
180 /**
181 * A new newFixedThreadPool with 0 threads throws IllegalArgumentException
182 */
183 public void testNewFixedThreadPool4() {
184 try {
185 ExecutorService unused = Executors.newFixedThreadPool(0);
186 shouldThrow();
187 } catch (IllegalArgumentException success) {}
188 }
189
190 /**
191 * An unconfigurable newFixedThreadPool can execute runnables
192 */
193 public void testUnconfigurableExecutorService() {
194 final ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
195 try (PoolCleaner cleaner = cleaner(e)) {
196 e.execute(new NoOpRunnable());
197 e.execute(new NoOpRunnable());
198 e.execute(new NoOpRunnable());
199 }
200 }
201
202 /**
203 * unconfigurableExecutorService(null) throws NPE
204 */
205 public void testUnconfigurableExecutorServiceNPE() {
206 try {
207 ExecutorService unused =
208 Executors.unconfigurableExecutorService(null);
209 shouldThrow();
210 } catch (NullPointerException success) {}
211 }
212
213 /**
214 * unconfigurableScheduledExecutorService(null) throws NPE
215 */
216 public void testUnconfigurableScheduledExecutorServiceNPE() {
217 try {
218 ExecutorService unused =
219 Executors.unconfigurableScheduledExecutorService(null);
220 shouldThrow();
221 } catch (NullPointerException success) {}
222 }
223
224 /**
225 * a newSingleThreadScheduledExecutor successfully runs delayed task
226 */
227 public void testNewSingleThreadScheduledExecutor() throws Exception {
228 final ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor();
229 try (PoolCleaner cleaner = cleaner(p)) {
230 final CountDownLatch proceed = new CountDownLatch(1);
231 final Runnable task = new CheckedRunnable() {
232 public void realRun() {
233 await(proceed);
234 }};
235 long startTime = System.nanoTime();
236 Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
237 timeoutMillis(), MILLISECONDS);
238 assertFalse(f.isDone());
239 proceed.countDown();
289 proceed.countDown();
290 assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
291 assertSame(Boolean.TRUE, f.get());
292 assertTrue(f.isDone());
293 assertFalse(f.isCancelled());
294 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
295 }
296 }
297
298 /**
299 * Future.get on submitted tasks will time out if they compute too long.
300 */
301 public void testTimedCallable() throws Exception {
302 final ExecutorService[] executors = {
303 Executors.newSingleThreadExecutor(),
304 Executors.newCachedThreadPool(),
305 Executors.newFixedThreadPool(2),
306 Executors.newScheduledThreadPool(2),
307 };
308
309 final CountDownLatch done = new CountDownLatch(1);
310
311 final Runnable sleeper = new CheckedRunnable() {
312 public void realRun() throws InterruptedException {
313 done.await(LONG_DELAY_MS, MILLISECONDS);
314 }};
315
316 List<Thread> threads = new ArrayList<>();
317 for (final ExecutorService executor : executors) {
318 threads.add(newStartedThread(new CheckedRunnable() {
319 public void realRun() {
320 Future future = executor.submit(sleeper);
321 assertFutureTimesOut(future);
322 }}));
323 }
324 for (Thread thread : threads)
325 awaitTermination(thread);
326 done.countDown();
327 for (ExecutorService executor : executors)
328 joinPool(executor);
329 }
330
331 /**
332 * ThreadPoolExecutor using defaultThreadFactory has
333 * specified group, priority, daemon status, and name
334 */
335 public void testDefaultThreadFactory() throws Exception {
336 final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
337 final CountDownLatch done = new CountDownLatch(1);
338 Runnable r = new CheckedRunnable() {
339 public void realRun() {
340 try {
341 Thread current = Thread.currentThread();
342 assertFalse(current.isDaemon());
343 assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
344 SecurityManager s = System.getSecurityManager();
345 assertSame(current.getThreadGroup(),
346 (s == null) ? egroup : s.getThreadGroup());
566 public void testCallable3() throws Exception {
567 Callable c = Executors.callable(new PrivilegedAction() {
568 public Object run() { return one; }});
569 assertSame(one, c.call());
570 }
571
572 /**
573 * callable(PrivilegedExceptionAction) returns its result when called
574 */
575 public void testCallable4() throws Exception {
576 Callable c = Executors.callable(new PrivilegedExceptionAction() {
577 public Object run() { return one; }});
578 assertSame(one, c.call());
579 }
580
581 /**
582 * callable(null Runnable) throws NPE
583 */
584 public void testCallableNPE1() {
585 try {
586 Callable unused = Executors.callable((Runnable) null);
587 shouldThrow();
588 } catch (NullPointerException success) {}
589 }
590
591 /**
592 * callable(null, result) throws NPE
593 */
594 public void testCallableNPE2() {
595 try {
596 Callable unused = Executors.callable((Runnable) null, one);
597 shouldThrow();
598 } catch (NullPointerException success) {}
599 }
600
601 /**
602 * callable(null PrivilegedAction) throws NPE
603 */
604 public void testCallableNPE3() {
605 try {
606 Callable unused = Executors.callable((PrivilegedAction) null);
607 shouldThrow();
608 } catch (NullPointerException success) {}
609 }
610
611 /**
612 * callable(null PrivilegedExceptionAction) throws NPE
613 */
614 public void testCallableNPE4() {
615 try {
616 Callable unused = Executors.callable((PrivilegedExceptionAction) null);
617 shouldThrow();
618 } catch (NullPointerException success) {}
619 }
620
621 /**
622 * callable(runnable, x).toString() contains toString of wrapped task
623 */
624 public void testCallable_withResult_toString() {
625 if (testImplementationDetails) {
626 Runnable r = () -> {};
627 Callable<String> c = Executors.callable(r, "");
628 assertEquals(
629 identityString(c) + "[Wrapped task = " + r.toString() + "]",
630 c.toString());
631 }
632 }
633
634 /**
635 * callable(runnable).toString() contains toString of wrapped task
636 */
|