117 |
|
unexpectedException(); |
118 |
|
} |
119 |
|
assertEquals(1, p2.getCompletedTaskCount()); |
120 |
< |
p2.shutdown(); |
120 |
> |
try { p2.shutdown(); } catch(SecurityException ok) { return; } |
121 |
|
joinPool(p2); |
122 |
|
} |
123 |
|
|
147 |
|
ThreadFactory tf = new SimpleThreadFactory(); |
148 |
|
ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler()); |
149 |
|
assertSame(tf, p.getThreadFactory()); |
150 |
– |
p.shutdown(); |
150 |
|
joinPool(p); |
151 |
|
} |
152 |
|
|
158 |
|
ThreadFactory tf = new SimpleThreadFactory(); |
159 |
|
p.setThreadFactory(tf); |
160 |
|
assertSame(tf, p.getThreadFactory()); |
162 |
– |
p.shutdown(); |
161 |
|
joinPool(p); |
162 |
|
} |
163 |
|
|
183 |
|
RejectedExecutionHandler h = new NoOpREHandler(); |
184 |
|
ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h); |
185 |
|
assertSame(h, p.getRejectedExecutionHandler()); |
188 |
– |
p.shutdown(); |
186 |
|
joinPool(p); |
187 |
|
} |
188 |
|
|
195 |
|
RejectedExecutionHandler h = new NoOpREHandler(); |
196 |
|
p.setRejectedExecutionHandler(h); |
197 |
|
assertSame(h, p.getRejectedExecutionHandler()); |
201 |
– |
p.shutdown(); |
198 |
|
joinPool(p); |
199 |
|
} |
200 |
|
|
277 |
|
|
278 |
|
ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
279 |
|
assertFalse(p1.isShutdown()); |
280 |
< |
p1.shutdown(); |
280 |
> |
try { p1.shutdown(); } catch(SecurityException ok) { return; } |
281 |
|
assertTrue(p1.isShutdown()); |
282 |
|
joinPool(p1); |
283 |
|
} |
292 |
|
try { |
293 |
|
p1.execute(new MediumRunnable()); |
294 |
|
} finally { |
295 |
< |
p1.shutdown(); |
295 |
> |
try { p1.shutdown(); } catch(SecurityException ok) { return; } |
296 |
|
} |
297 |
|
try { |
298 |
|
assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); |
312 |
|
p1.execute(new SmallRunnable()); |
313 |
|
assertFalse(p1.isTerminating()); |
314 |
|
} finally { |
315 |
< |
p1.shutdown(); |
315 |
> |
try { p1.shutdown(); } catch(SecurityException ok) { return; } |
316 |
|
} |
317 |
|
try { |
318 |
|
assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); |
340 |
|
assertSame(q, wq); |
341 |
|
assertFalse(wq.contains(tasks[0])); |
342 |
|
assertTrue(wq.contains(tasks[4])); |
347 |
– |
p1.shutdownNow(); |
343 |
|
} catch(Exception e) { |
344 |
|
unexpectedException(); |
345 |
|
} finally { |
369 |
|
assertTrue(q.contains(tasks[3])); |
370 |
|
assertTrue(p1.remove(tasks[3])); |
371 |
|
assertFalse(q.contains(tasks[3])); |
377 |
– |
p1.shutdownNow(); |
372 |
|
} catch(Exception e) { |
373 |
|
unexpectedException(); |
374 |
|
} finally { |
391 |
|
p1.purge(); |
392 |
|
long count = p1.getTaskCount(); |
393 |
|
assertTrue(count >= 2 && count < 5); |
400 |
– |
p1.shutdownNow(); |
394 |
|
joinPool(p1); |
395 |
|
} |
396 |
|
|
405 |
|
p1.execute(new MediumPossiblyInterruptedRunnable()); |
406 |
|
} |
407 |
|
finally { |
408 |
< |
l = p1.shutdownNow(); |
408 |
> |
try { |
409 |
> |
l = p1.shutdownNow(); |
410 |
> |
} catch (SecurityException ok) { return; } |
411 |
> |
|
412 |
|
} |
413 |
|
assertTrue(p1.isShutdown()); |
414 |
|
assertTrue(l.size() <= 4); |
769 |
|
for(int i = 1; i < 5; ++i) { |
770 |
|
assertTrue(tasks[i].done); |
771 |
|
} |
776 |
– |
p.shutdownNow(); |
772 |
|
} catch(RejectedExecutionException ex){ |
773 |
|
unexpectedException(); |
774 |
|
} finally { |
795 |
|
for(int i = 0; i < 5; ++i){ |
796 |
|
assertFalse(tasks[i].done); |
797 |
|
} |
803 |
– |
p.shutdownNow(); |
798 |
|
} catch(RejectedExecutionException ex){ |
799 |
|
unexpectedException(); |
800 |
|
} finally { |
817 |
|
p.execute(r3); |
818 |
|
assertFalse(p.getQueue().contains(r2)); |
819 |
|
assertTrue(p.getQueue().contains(r3)); |
826 |
– |
p.shutdownNow(); |
820 |
|
} catch(RejectedExecutionException ex){ |
821 |
|
unexpectedException(); |
822 |
|
} finally { |
830 |
|
public void testRejectedExecutionExceptionOnShutdown() { |
831 |
|
ThreadPoolExecutor tpe = |
832 |
|
new ThreadPoolExecutor(1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1)); |
833 |
< |
tpe.shutdown(); |
833 |
> |
try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
834 |
|
try { |
835 |
|
tpe.execute(new NoOpRunnable()); |
836 |
|
shouldThrow(); |
846 |
|
RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy(); |
847 |
|
ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); |
848 |
|
|
849 |
< |
p.shutdown(); |
849 |
> |
try { p.shutdown(); } catch(SecurityException ok) { return; } |
850 |
|
try { |
851 |
|
TrackedNoOpRunnable r = new TrackedNoOpRunnable(); |
852 |
|
p.execute(r); |
865 |
|
RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy(); |
866 |
|
ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); |
867 |
|
|
868 |
< |
p.shutdown(); |
868 |
> |
try { p.shutdown(); } catch(SecurityException ok) { return; } |
869 |
|
try { |
870 |
|
TrackedNoOpRunnable r = new TrackedNoOpRunnable(); |
871 |
|
p.execute(r); |
885 |
|
RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy(); |
886 |
|
ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); |
887 |
|
|
888 |
< |
p.shutdown(); |
888 |
> |
try { p.shutdown(); } catch(SecurityException ok) { return; } |
889 |
|
try { |
890 |
|
TrackedNoOpRunnable r = new TrackedNoOpRunnable(); |
891 |
|
p.execute(r); |
925 |
|
shouldThrow(); |
926 |
|
} catch(IllegalArgumentException success){ |
927 |
|
} finally { |
928 |
< |
tpe.shutdown(); |
928 |
> |
try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
929 |
|
} |
930 |
|
joinPool(tpe); |
931 |
|
} |
944 |
|
shouldThrow(); |
945 |
|
} catch(IllegalArgumentException success){ |
946 |
|
} finally { |
947 |
< |
tpe.shutdown(); |
947 |
> |
try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
948 |
|
} |
949 |
|
joinPool(tpe); |
950 |
|
} |
963 |
|
shouldThrow(); |
964 |
|
} catch(IllegalArgumentException success){ |
965 |
|
} finally { |
966 |
< |
tpe.shutdown(); |
966 |
> |
try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
967 |
|
} |
968 |
|
joinPool(tpe); |
969 |
|
} |
984 |
|
shouldThrow(); |
985 |
|
} catch(IllegalArgumentException success){ |
986 |
|
} finally { |
987 |
< |
tpe.shutdown(); |
987 |
> |
try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
988 |
|
} |
989 |
|
joinPool(tpe); |
990 |
|
} |
994 |
|
*/ |
995 |
|
public void testTerminated() { |
996 |
|
ExtendedTPE tpe = new ExtendedTPE(); |
997 |
< |
tpe.shutdown(); |
997 |
> |
try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
998 |
|
assertTrue(tpe.terminatedCalled); |
999 |
|
joinPool(tpe); |
1000 |
|
} |
1011 |
|
assertTrue(r.done); |
1012 |
|
assertTrue(tpe.beforeCalled); |
1013 |
|
assertTrue(tpe.afterCalled); |
1014 |
< |
tpe.shutdown(); |
1014 |
> |
try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
1015 |
|
} |
1016 |
|
catch(Exception ex) { |
1017 |
|
unexpectedException(); |