ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ExecutorsTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ExecutorsTest.java (file contents):
Revision 1.8 by dl, Sat Nov 1 18:37:02 2003 UTC vs.
Revision 1.49 by jsr166, Mon May 29 22:44:26 2017 UTC

# Line 1 | Line 1
1   /*
2 < * Written by members of JCP JSR-166 Expert Group and released to the
3 < * public domain. Use, modify, and redistribute this code in any way
4 < * without acknowledgement. Other contributors include Andrew Wright,
5 < * Jeffrey Hayes, Pat Fischer, Mike Judd.
2 > * Written by Doug Lea with assistance from members of JCP JSR-166
3 > * Expert Group and released to the public domain, as explained at
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9 + import static java.util.concurrent.TimeUnit.MILLISECONDS;
10  
11 < import junit.framework.*;
12 < import java.util.*;
13 < import java.util.concurrent.*;
14 < import java.math.BigInteger;
15 < import java.security.*;
11 > import java.security.AccessControlContext;
12 > import java.security.AccessControlException;
13 > import java.security.AccessController;
14 > import java.security.PrivilegedAction;
15 > import java.security.PrivilegedExceptionAction;
16 > import java.util.ArrayList;
17 > import java.util.List;
18 > import java.util.concurrent.Callable;
19 > import java.util.concurrent.CountDownLatch;
20 > import java.util.concurrent.Executors;
21 > import java.util.concurrent.ExecutorService;
22 > import java.util.concurrent.Future;
23 > import java.util.concurrent.ScheduledExecutorService;
24 > import java.util.concurrent.ThreadPoolExecutor;
25  
26 < public class ExecutorsTest extends JSR166TestCase{
26 > import junit.framework.Test;
27 > import junit.framework.TestSuite;
28 >
29 > public class ExecutorsTest extends JSR166TestCase {
30      public static void main(String[] args) {
31 <        junit.textui.TestRunner.run (suite());  
31 >        main(suite(), args);
32      }
33      public static Test suite() {
34 <        return new TestSuite(ExecutorsTest.class);
21 <    }
22 <
23 <    private static final String TEST_STRING = "a test string";
24 <
25 <    private static class StringTask implements Callable<String> {
26 <        public String call() { return TEST_STRING; }
34 >        return new TestSuite(ExecutorsTest.class);
35      }
36  
29    static class DirectExecutor implements Executor {
30        public void execute(Runnable r) {
31            r.run();
32        }
33    }
34
35    static class TimedCallable<T> implements Callable<T> {
36        private final Executor exec;
37        private final Callable<T> func;
38        private final long msecs;
39        
40        TimedCallable(Executor exec, Callable<T> func, long msecs) {
41            this.exec = exec;
42            this.func = func;
43            this.msecs = msecs;
44        }
45        
46        public T call() throws Exception {
47            Future<T> ftask = Executors.execute(exec, func);
48            try {
49                return ftask.get(msecs, TimeUnit.MILLISECONDS);
50            } finally {
51                ftask.cancel(true);
52            }
53        }
54    }
55
56
57    private static class Fib implements Callable<BigInteger> {
58        private final BigInteger n;
59        Fib(long n) {
60            if (n < 0) throw new IllegalArgumentException("need non-negative arg, but got " + n);
61            this.n = BigInteger.valueOf(n);
62        }
63        public BigInteger call() {
64            BigInteger f1 = BigInteger.ONE;
65            BigInteger f2 = f1;
66            for (BigInteger i = BigInteger.ZERO; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) {
67                BigInteger t = f1.add(f2);
68                f1 = f2;
69                f2 = t;
70            }
71            return f1;
72        }
73    };
74
37      /**
38       * A newCachedThreadPool can execute runnables
39       */
40      public void testNewCachedThreadPool1() {
41 <        ExecutorService e = Executors.newCachedThreadPool();
42 <        e.execute(new NoOpRunnable());
43 <        e.execute(new NoOpRunnable());
44 <        e.execute(new NoOpRunnable());
45 <        e.shutdown();
41 >        final ExecutorService e = Executors.newCachedThreadPool();
42 >        try (PoolCleaner cleaner = cleaner(e)) {
43 >            e.execute(new NoOpRunnable());
44 >            e.execute(new NoOpRunnable());
45 >            e.execute(new NoOpRunnable());
46 >        }
47      }
48  
49      /**
50       * A newCachedThreadPool with given ThreadFactory can execute runnables
51       */
52      public void testNewCachedThreadPool2() {
53 <        ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
54 <        e.execute(new NoOpRunnable());
55 <        e.execute(new NoOpRunnable());
56 <        e.execute(new NoOpRunnable());
57 <        e.shutdown();
53 >        final ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
54 >        try (PoolCleaner cleaner = cleaner(e)) {
55 >            e.execute(new NoOpRunnable());
56 >            e.execute(new NoOpRunnable());
57 >            e.execute(new NoOpRunnable());
58 >        }
59      }
60  
61      /**
# Line 101 | Line 65 | public class ExecutorsTest extends JSR16
65          try {
66              ExecutorService e = Executors.newCachedThreadPool(null);
67              shouldThrow();
68 <        }
105 <        catch(NullPointerException success) {
106 <        }
68 >        } catch (NullPointerException success) {}
69      }
70  
109
71      /**
72       * A new SingleThreadExecutor can execute runnables
73       */
74      public void testNewSingleThreadExecutor1() {
75 <        ExecutorService e = Executors.newSingleThreadExecutor();
76 <        e.execute(new NoOpRunnable());
77 <        e.execute(new NoOpRunnable());
78 <        e.execute(new NoOpRunnable());
79 <        e.shutdown();
75 >        final ExecutorService e = Executors.newSingleThreadExecutor();
76 >        try (PoolCleaner cleaner = cleaner(e)) {
77 >            e.execute(new NoOpRunnable());
78 >            e.execute(new NoOpRunnable());
79 >            e.execute(new NoOpRunnable());
80 >        }
81      }
82  
83      /**
84       * A new SingleThreadExecutor with given ThreadFactory can execute runnables
85       */
86      public void testNewSingleThreadExecutor2() {
87 <        ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
88 <        e.execute(new NoOpRunnable());
89 <        e.execute(new NoOpRunnable());
90 <        e.execute(new NoOpRunnable());
91 <        e.shutdown();
87 >        final ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
88 >        try (PoolCleaner cleaner = cleaner(e)) {
89 >            e.execute(new NoOpRunnable());
90 >            e.execute(new NoOpRunnable());
91 >            e.execute(new NoOpRunnable());
92 >        }
93      }
94  
95      /**
# Line 136 | Line 99 | public class ExecutorsTest extends JSR16
99          try {
100              ExecutorService e = Executors.newSingleThreadExecutor(null);
101              shouldThrow();
102 <        }
103 <        catch(NullPointerException success) {
102 >        } catch (NullPointerException success) {}
103 >    }
104 >
105 >    /**
106 >     * A new SingleThreadExecutor cannot be casted to concrete implementation
107 >     */
108 >    public void testCastNewSingleThreadExecutor() {
109 >        final ExecutorService e = Executors.newSingleThreadExecutor();
110 >        try (PoolCleaner cleaner = cleaner(e)) {
111 >            try {
112 >                ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
113 >                shouldThrow();
114 >            } catch (ClassCastException success) {}
115          }
116      }
117  
# Line 145 | Line 119 | public class ExecutorsTest extends JSR16
119       * A new newFixedThreadPool can execute runnables
120       */
121      public void testNewFixedThreadPool1() {
122 <        ExecutorService e = Executors.newFixedThreadPool(2);
123 <        e.execute(new NoOpRunnable());
124 <        e.execute(new NoOpRunnable());
125 <        e.execute(new NoOpRunnable());
126 <        e.shutdown();
122 >        final ExecutorService e = Executors.newFixedThreadPool(2);
123 >        try (PoolCleaner cleaner = cleaner(e)) {
124 >            e.execute(new NoOpRunnable());
125 >            e.execute(new NoOpRunnable());
126 >            e.execute(new NoOpRunnable());
127 >        }
128      }
129  
130      /**
131       * A new newFixedThreadPool with given ThreadFactory can execute runnables
132       */
133      public void testNewFixedThreadPool2() {
134 <        ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
135 <        e.execute(new NoOpRunnable());
136 <        e.execute(new NoOpRunnable());
137 <        e.execute(new NoOpRunnable());
138 <        e.shutdown();
134 >        final ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
135 >        try (PoolCleaner cleaner = cleaner(e)) {
136 >            e.execute(new NoOpRunnable());
137 >            e.execute(new NoOpRunnable());
138 >            e.execute(new NoOpRunnable());
139 >        }
140      }
141  
142      /**
143 <     * A new newFixedThreadPool with null ThreadFactory throws NPE
143 >     * A new newFixedThreadPool with null ThreadFactory throws
144 >     * NullPointerException
145       */
146      public void testNewFixedThreadPool3() {
147          try {
148              ExecutorService e = Executors.newFixedThreadPool(2, null);
149              shouldThrow();
150 <        }
174 <        catch(NullPointerException success) {
175 <        }
150 >        } catch (NullPointerException success) {}
151      }
152  
153      /**
154 <     * A new newFixedThreadPool with 0 threads throws IAE
154 >     * A new newFixedThreadPool with 0 threads throws IllegalArgumentException
155       */
156      public void testNewFixedThreadPool4() {
157          try {
158              ExecutorService e = Executors.newFixedThreadPool(0);
159              shouldThrow();
160 <        }
186 <        catch(IllegalArgumentException success) {
187 <        }
160 >        } catch (IllegalArgumentException success) {}
161      }
162  
163      /**
164 <     * execute of runnable runs it to completion
164 >     * An unconfigurable newFixedThreadPool can execute runnables
165       */
166 <    public void testExecuteRunnable() {
167 <        try {
168 <            Executor e = new DirectExecutor();
169 <            TrackedShortRunnable task = new TrackedShortRunnable();
170 <            assertFalse(task.done);
171 <            Future<String> future = Executors.execute(e, task, TEST_STRING);
199 <            String result = future.get();
200 <            assertTrue(task.done);
201 <            assertSame(TEST_STRING, result);
202 <        }
203 <        catch (ExecutionException ex) {
204 <            unexpectedException();
205 <        }
206 <        catch (InterruptedException ex) {
207 <            unexpectedException();
166 >    public void testUnconfigurableExecutorService() {
167 >        final ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
168 >        try (PoolCleaner cleaner = cleaner(e)) {
169 >            e.execute(new NoOpRunnable());
170 >            e.execute(new NoOpRunnable());
171 >            e.execute(new NoOpRunnable());
172          }
173      }
174  
175      /**
176 <     * invoke of a runnable runs it to completion
176 >     * unconfigurableExecutorService(null) throws NPE
177       */
178 <    public void testInvokeRunnable() {
178 >    public void testUnconfigurableExecutorServiceNPE() {
179          try {
180 <            Executor e = new DirectExecutor();
181 <            TrackedShortRunnable task = new TrackedShortRunnable();
182 <            assertFalse(task.done);
219 <            Executors.invoke(e, task);
220 <            assertTrue(task.done);
221 <        }
222 <        catch (ExecutionException ex) {
223 <            unexpectedException();
224 <        }
225 <        catch (InterruptedException ex) {
226 <            unexpectedException();
227 <        }
180 >            ExecutorService e = Executors.unconfigurableExecutorService(null);
181 >            shouldThrow();
182 >        } catch (NullPointerException success) {}
183      }
184  
185      /**
186 <     * execute of a callable runs it to completion
186 >     * unconfigurableScheduledExecutorService(null) throws NPE
187       */
188 <    public void testExecuteCallable() {
188 >    public void testUnconfigurableScheduledExecutorServiceNPE() {
189          try {
190 <            Executor e = new DirectExecutor();
191 <            Future<String> future = Executors.execute(e, new StringTask());
192 <            String result = future.get();
238 <            assertSame(TEST_STRING, result);
239 <        }
240 <        catch (ExecutionException ex) {
241 <            unexpectedException();
242 <        }
243 <        catch (InterruptedException ex) {
244 <            unexpectedException();
245 <        }
190 >            ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
191 >            shouldThrow();
192 >        } catch (NullPointerException success) {}
193      }
194  
248
195      /**
196 <     * execute of a privileged action runs it to completion
196 >     * a newSingleThreadScheduledExecutor successfully runs delayed task
197       */
198 <    public void testExecutePrivilegedAction() {
199 <        Policy savedPolicy = Policy.getPolicy();
200 <        AdjustablePolicy policy = new AdjustablePolicy();
201 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
202 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
203 <        Policy.setPolicy(policy);
204 <        try {
205 <            Executor e = new DirectExecutor();
206 <            Future future = Executors.execute(e, new PrivilegedAction() {
207 <                    public Object run() {
208 <                        return TEST_STRING;
209 <                    }});
210 <
211 <            Object result = future.get();
212 <            assertSame(TEST_STRING, result);
213 <        }
214 <        catch (ExecutionException ex) {
215 <            unexpectedException();
198 >    public void testNewSingleThreadScheduledExecutor() throws Exception {
199 >        final ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor();
200 >        try (PoolCleaner cleaner = cleaner(p)) {
201 >            final CountDownLatch proceed = new CountDownLatch(1);
202 >            final Runnable task = new CheckedRunnable() {
203 >                public void realRun() {
204 >                    await(proceed);
205 >                }};
206 >            long startTime = System.nanoTime();
207 >            Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
208 >                                  timeoutMillis(), MILLISECONDS);
209 >            assertFalse(f.isDone());
210 >            proceed.countDown();
211 >            assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
212 >            assertSame(Boolean.TRUE, f.get());
213 >            assertTrue(f.isDone());
214 >            assertFalse(f.isCancelled());
215 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
216          }
271        catch (InterruptedException ex) {
272            unexpectedException();
273        }
274        finally {
275            Policy.setPolicy(savedPolicy);
276        }
217      }
218  
219      /**
220 <     * execute of a privileged exception action runs it to completion
220 >     * a newScheduledThreadPool successfully runs delayed task
221       */
222 <    public void testExecutePrivilegedExceptionAction() {
223 <        Policy savedPolicy = Policy.getPolicy();
224 <        AdjustablePolicy policy = new AdjustablePolicy();
225 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
226 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
227 <        Policy.setPolicy(policy);
228 <        try {
229 <            Executor e = new DirectExecutor();
230 <            Future future = Executors.execute(e, new PrivilegedExceptionAction() {
231 <                    public Object run() {
232 <                        return TEST_STRING;
233 <                    }});
234 <
235 <            Object result = future.get();
236 <            assertSame(TEST_STRING, result);
237 <        }
238 <        catch (ExecutionException ex) {
239 <            unexpectedException();
300 <        }
301 <        catch (InterruptedException ex) {
302 <            unexpectedException();
222 >    public void testNewScheduledThreadPool() throws Exception {
223 >        final ScheduledExecutorService p = Executors.newScheduledThreadPool(2);
224 >        try (PoolCleaner cleaner = cleaner(p)) {
225 >            final CountDownLatch proceed = new CountDownLatch(1);
226 >            final Runnable task = new CheckedRunnable() {
227 >                public void realRun() {
228 >                    await(proceed);
229 >                }};
230 >            long startTime = System.nanoTime();
231 >            Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
232 >                                  timeoutMillis(), MILLISECONDS);
233 >            assertFalse(f.isDone());
234 >            proceed.countDown();
235 >            assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
236 >            assertSame(Boolean.TRUE, f.get());
237 >            assertTrue(f.isDone());
238 >            assertFalse(f.isCancelled());
239 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
240          }
304        finally {
305            Policy.setPolicy(savedPolicy);
306        }
241      }
242  
243      /**
244 <     * execute of a failed privileged exception action reports exception
244 >     * an unconfigurable newScheduledThreadPool successfully runs delayed task
245       */
246 <    public void testExecuteFailedPrivilegedExceptionAction() {
247 <        Policy savedPolicy = Policy.getPolicy();
248 <        AdjustablePolicy policy = new AdjustablePolicy();
249 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
250 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
251 <        Policy.setPolicy(policy);
252 <        try {
253 <            Executor e = new DirectExecutor();
254 <            Future future = Executors.execute(e, new PrivilegedExceptionAction() {
255 <                    public Object run() throws Exception {
256 <                        throw new IndexOutOfBoundsException();
257 <                    }});
258 <
259 <            Object result = future.get();
260 <            shouldThrow();
261 <        }
262 <        catch (ExecutionException success) {
263 <        }
264 <        catch (InterruptedException ex) {
265 <            unexpectedException();
246 >    public void testUnconfigurableScheduledExecutorService() throws Exception {
247 >        final ScheduledExecutorService p =
248 >            Executors.unconfigurableScheduledExecutorService
249 >            (Executors.newScheduledThreadPool(2));
250 >        try (PoolCleaner cleaner = cleaner(p)) {
251 >            final CountDownLatch proceed = new CountDownLatch(1);
252 >            final Runnable task = new CheckedRunnable() {
253 >                public void realRun() {
254 >                    await(proceed);
255 >                }};
256 >            long startTime = System.nanoTime();
257 >            Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
258 >                                  timeoutMillis(), MILLISECONDS);
259 >            assertFalse(f.isDone());
260 >            proceed.countDown();
261 >            assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
262 >            assertSame(Boolean.TRUE, f.get());
263 >            assertTrue(f.isDone());
264 >            assertFalse(f.isCancelled());
265 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
266          }
333        finally {
334            Policy.setPolicy(savedPolicy);
335        }
267      }
268  
269      /**
270 <     * invoke of a collable runs it to completion
270 >     * Future.get on submitted tasks will time out if they compute too long.
271       */
272 <    public void testInvokeCallable() {
273 <        try {
274 <            Executor e = new DirectExecutor();
275 <            String result = Executors.invoke(e, new StringTask());
272 >    public void testTimedCallable() throws Exception {
273 >        final ExecutorService[] executors = {
274 >            Executors.newSingleThreadExecutor(),
275 >            Executors.newCachedThreadPool(),
276 >            Executors.newFixedThreadPool(2),
277 >            Executors.newScheduledThreadPool(2),
278 >        };
279  
280 <            assertSame(TEST_STRING, result);
281 <        }
282 <        catch (ExecutionException ex) {
283 <            unexpectedException();
284 <        }
285 <        catch (InterruptedException ex) {
286 <            unexpectedException();
280 >        final Runnable sleeper = new CheckedInterruptedRunnable() {
281 >            public void realRun() throws InterruptedException {
282 >                delay(LONG_DELAY_MS);
283 >            }};
284 >
285 >        List<Thread> threads = new ArrayList<>();
286 >        for (final ExecutorService executor : executors) {
287 >            threads.add(newStartedThread(new CheckedRunnable() {
288 >                public void realRun() {
289 >                    Future future = executor.submit(sleeper);
290 >                    assertFutureTimesOut(future);
291 >                }}));
292          }
293 +        for (Thread thread : threads)
294 +            awaitTermination(thread);
295 +        for (ExecutorService executor : executors)
296 +            joinPool(executor);
297      }
298  
299      /**
300 <     * execute with null executor throws NPE
300 >     * ThreadPoolExecutor using defaultThreadFactory has
301 >     * specified group, priority, daemon status, and name
302       */
303 <    public void testNullExecuteRunnable() {
304 <        try {
305 <            TrackedShortRunnable task = new TrackedShortRunnable();
306 <            assertFalse(task.done);
307 <            Future<String> future = Executors.execute(null, task, TEST_STRING);
308 <            shouldThrow();
309 <        }
310 <        catch (NullPointerException success) {
311 <        }
312 <        catch (Exception ex) {
313 <            unexpectedException();
303 >    public void testDefaultThreadFactory() throws Exception {
304 >        final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
305 >        final CountDownLatch done = new CountDownLatch(1);
306 >        Runnable r = new CheckedRunnable() {
307 >            public void realRun() {
308 >                try {
309 >                    Thread current = Thread.currentThread();
310 >                    assertFalse(current.isDaemon());
311 >                    assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
312 >                    SecurityManager s = System.getSecurityManager();
313 >                    assertSame(current.getThreadGroup(),
314 >                               (s == null) ? egroup : s.getThreadGroup());
315 >                    assertTrue(current.getName().endsWith("thread-1"));
316 >                } catch (SecurityException ok) {
317 >                    // Also pass if not allowed to change setting
318 >                }
319 >                done.countDown();
320 >            }};
321 >        ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
322 >        try (PoolCleaner cleaner = cleaner(e)) {
323 >            e.execute(r);
324 >            await(done);
325          }
326      }
327  
328      /**
329 <     * execute with a null runnable throws NPE
329 >     * ThreadPoolExecutor using privilegedThreadFactory has
330 >     * specified group, priority, daemon status, name,
331 >     * access control context and context class loader
332       */
333 <    public void testExecuteNullRunnable() {
334 <        try {
335 <            Executor e = new DirectExecutor();
336 <            TrackedShortRunnable task = null;
337 <            Future<String> future = Executors.execute(e, task, TEST_STRING);
338 <            shouldThrow();
333 >    public void testPrivilegedThreadFactory() throws Exception {
334 >        final CountDownLatch done = new CountDownLatch(1);
335 >        Runnable r = new CheckedRunnable() {
336 >            public void realRun() throws Exception {
337 >                final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
338 >                final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
339 >                final AccessControlContext thisacc = AccessController.getContext();
340 >                Runnable r = new CheckedRunnable() {
341 >                    public void realRun() {
342 >                        Thread current = Thread.currentThread();
343 >                        assertFalse(current.isDaemon());
344 >                        assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
345 >                        SecurityManager s = System.getSecurityManager();
346 >                        assertSame(current.getThreadGroup(),
347 >                                   (s == null) ? egroup : s.getThreadGroup());
348 >                        assertTrue(current.getName().endsWith("thread-1"));
349 >                        assertSame(thisccl, current.getContextClassLoader());
350 >                        assertEquals(thisacc, AccessController.getContext());
351 >                        done.countDown();
352 >                    }};
353 >                ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
354 >                try (PoolCleaner cleaner = cleaner(e)) {
355 >                    e.execute(r);
356 >                    await(done);
357 >                }
358 >            }};
359 >
360 >        runWithPermissions(r,
361 >                           new RuntimePermission("getClassLoader"),
362 >                           new RuntimePermission("setContextClassLoader"),
363 >                           new RuntimePermission("modifyThread"));
364 >    }
365 >
366 >    boolean haveCCLPermissions() {
367 >        SecurityManager sm = System.getSecurityManager();
368 >        if (sm != null) {
369 >            try {
370 >                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
371 >                sm.checkPermission(new RuntimePermission("getClassLoader"));
372 >            } catch (AccessControlException e) {
373 >                return false;
374 >            }
375          }
376 <        catch (NullPointerException success) {
376 >        return true;
377 >    }
378 >
379 >    void checkCCL() {
380 >        SecurityManager sm = System.getSecurityManager();
381 >        if (sm != null) {
382 >            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
383 >            sm.checkPermission(new RuntimePermission("getClassLoader"));
384          }
385 <        catch (Exception ex) {
386 <            unexpectedException();
385 >    }
386 >
387 >    class CheckCCL implements Callable<Object> {
388 >        public Object call() {
389 >            checkCCL();
390 >            return null;
391          }
392      }
393  
394      /**
395 <     * invoke of a null runnable throws NPE
395 >     * Without class loader permissions, creating
396 >     * privilegedCallableUsingCurrentClassLoader throws ACE
397       */
398 <    public void testInvokeNullRunnable() {
399 <        try {
400 <            Executor e = new DirectExecutor();
401 <            TrackedShortRunnable task = null;
402 <            Executors.invoke(e, task);
403 <            shouldThrow();
404 <        }
405 <        catch (NullPointerException success) {
406 <        }
407 <        catch (Exception ex) {
408 <            unexpectedException();
409 <        }
398 >    public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
399 >        Runnable r = new CheckedRunnable() {
400 >            public void realRun() throws Exception {
401 >                if (System.getSecurityManager() == null)
402 >                    return;
403 >                try {
404 >                    Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
405 >                    shouldThrow();
406 >                } catch (AccessControlException success) {}
407 >            }};
408 >
409 >        runWithoutPermissions(r);
410      }
411  
412      /**
413 <     * execute of a null callable throws NPE
413 >     * With class loader permissions, calling
414 >     * privilegedCallableUsingCurrentClassLoader does not throw ACE
415       */
416 <    public void testExecuteNullCallable() {
417 <        try {
418 <            Executor e = new DirectExecutor();
419 <            StringTask t = null;
420 <            Future<String> future = Executors.execute(e, t);
421 <            shouldThrow();
422 <        }
423 <        catch (NullPointerException success) {
424 <        }
425 <        catch (Exception ex) {
426 <            unexpectedException();
421 <        }
416 >    public void testPrivilegedCallableUsingCCLWithPrivs() throws Exception {
417 >        Runnable r = new CheckedRunnable() {
418 >            public void realRun() throws Exception {
419 >                Executors.privilegedCallableUsingCurrentClassLoader
420 >                    (new NoOpCallable())
421 >                    .call();
422 >            }};
423 >
424 >        runWithPermissions(r,
425 >                           new RuntimePermission("getClassLoader"),
426 >                           new RuntimePermission("setContextClassLoader"));
427      }
428  
429      /**
430 <     * invoke of a null callable throws NPE
430 >     * Without permissions, calling privilegedCallable throws ACE
431       */
432 <    public void testInvokeNullCallable() {
433 <        try {
434 <            Executor e = new DirectExecutor();
435 <            StringTask t = null;
436 <            String result = Executors.invoke(e, t);
437 <            shouldThrow();
438 <        }
439 <        catch (NullPointerException success) {
440 <        }
441 <        catch (Exception ex) {
442 <            unexpectedException();
443 <        }
432 >    public void testPrivilegedCallableWithNoPrivs() throws Exception {
433 >        // Avoid classloader-related SecurityExceptions in swingui.TestRunner
434 >        Executors.privilegedCallable(new CheckCCL());
435 >
436 >        Runnable r = new CheckedRunnable() {
437 >            public void realRun() throws Exception {
438 >                if (System.getSecurityManager() == null)
439 >                    return;
440 >                Callable task = Executors.privilegedCallable(new CheckCCL());
441 >                try {
442 >                    task.call();
443 >                    shouldThrow();
444 >                } catch (AccessControlException success) {}
445 >            }};
446 >
447 >        runWithoutPermissions(r);
448 >
449 >        // It seems rather difficult to test that the
450 >        // AccessControlContext of the privilegedCallable is used
451 >        // instead of its caller.  Below is a failed attempt to do
452 >        // that, which does not work because the AccessController
453 >        // cannot capture the internal state of the current Policy.
454 >        // It would be much more work to differentiate based on,
455 >        // e.g. CodeSource.
456 >
457 > //         final AccessControlContext[] noprivAcc = new AccessControlContext[1];
458 > //         final Callable[] task = new Callable[1];
459 >
460 > //         runWithPermissions
461 > //             (new CheckedRunnable() {
462 > //                 public void realRun() {
463 > //                     if (System.getSecurityManager() == null)
464 > //                         return;
465 > //                     noprivAcc[0] = AccessController.getContext();
466 > //                     task[0] = Executors.privilegedCallable(new CheckCCL());
467 > //                     try {
468 > //                         AccessController.doPrivileged(new PrivilegedAction<Void>() {
469 > //                                                           public Void run() {
470 > //                                                               checkCCL();
471 > //                                                               return null;
472 > //                                                           }}, noprivAcc[0]);
473 > //                         shouldThrow();
474 > //                     } catch (AccessControlException success) {}
475 > //                 }});
476 >
477 > //         runWithPermissions
478 > //             (new CheckedRunnable() {
479 > //                 public void realRun() throws Exception {
480 > //                     if (System.getSecurityManager() == null)
481 > //                         return;
482 > //                     // Verify that we have an underprivileged ACC
483 > //                     try {
484 > //                         AccessController.doPrivileged(new PrivilegedAction<Void>() {
485 > //                                                           public Void run() {
486 > //                                                               checkCCL();
487 > //                                                               return null;
488 > //                                                           }}, noprivAcc[0]);
489 > //                         shouldThrow();
490 > //                     } catch (AccessControlException success) {}
491 >
492 > //                     try {
493 > //                         task[0].call();
494 > //                         shouldThrow();
495 > //                     } catch (AccessControlException success) {}
496 > //                 }},
497 > //              new RuntimePermission("getClassLoader"),
498 > //              new RuntimePermission("setContextClassLoader"));
499      }
500  
501      /**
502 <     *  execute(Executor, Runnable) throws RejectedExecutionException
443 <     *  if saturated.
502 >     * With permissions, calling privilegedCallable succeeds
503       */
504 <    public void testExecute1() {
505 <        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
506 <        try {
507 <            
508 <            for(int i = 0; i < 5; ++i){
509 <                Executors.execute(p, new MediumRunnable(), Boolean.TRUE);
510 <            }
511 <            shouldThrow();
512 <        } catch(RejectedExecutionException success){}
454 <        joinPool(p);
504 >    public void testPrivilegedCallableWithPrivs() throws Exception {
505 >        Runnable r = new CheckedRunnable() {
506 >            public void realRun() throws Exception {
507 >                Executors.privilegedCallable(new CheckCCL()).call();
508 >            }};
509 >
510 >        runWithPermissions(r,
511 >                           new RuntimePermission("getClassLoader"),
512 >                           new RuntimePermission("setContextClassLoader"));
513      }
514  
515      /**
516 <     *  execute(Executor, Callable)throws RejectedExecutionException
459 <     *  if saturated.
516 >     * callable(Runnable) returns null when called
517       */
518 <    public void testExecute2() {
519 <         ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
520 <        try {
464 <            for(int i = 0; i < 5; ++i) {
465 <                Executors.execute(p, new SmallCallable());
466 <            }
467 <            shouldThrow();
468 <        } catch(RejectedExecutionException e){}
469 <        joinPool(p);
518 >    public void testCallable1() throws Exception {
519 >        Callable c = Executors.callable(new NoOpRunnable());
520 >        assertNull(c.call());
521      }
522  
472
523      /**
524 <     *  invoke(Executor, Runnable) throws InterruptedException if
475 <     *  caller interrupted.
524 >     * callable(Runnable, result) returns result when called
525       */
526 <    public void testInterruptedInvoke() {
527 <        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
528 <        Thread t = new Thread(new Runnable() {
480 <                public void run() {
481 <                    try {
482 <                        Executors.invoke(p,new Runnable() {
483 <                                public void run() {
484 <                                    try {
485 <                                        Thread.sleep(MEDIUM_DELAY_MS);
486 <                                        shouldThrow();
487 <                                    } catch(InterruptedException e){
488 <                                    }
489 <                                }
490 <                            });
491 <                    } catch(InterruptedException success){
492 <                    } catch(Exception e) {
493 <                        unexpectedException();
494 <                    }
495 <                    
496 <                }
497 <            });
498 <        try {
499 <            t.start();
500 <            Thread.sleep(SHORT_DELAY_MS);
501 <            t.interrupt();
502 <        } catch(Exception e){
503 <            unexpectedException();
504 <        }
505 <        joinPool(p);
526 >    public void testCallable2() throws Exception {
527 >        Callable c = Executors.callable(new NoOpRunnable(), one);
528 >        assertSame(one, c.call());
529      }
530  
531      /**
532 <     *  invoke(Executor, Runnable) throws ExecutionException if
510 <     *  runnable throws exception.
532 >     * callable(PrivilegedAction) returns its result when called
533       */
534 <    public void testInvoke3() {
535 <        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
536 <        try {
537 <            Runnable r = new Runnable() {
516 <                    public void run() {
517 <                        int i = 5/0;
518 <                    }
519 <                };
520 <            
521 <            for(int i =0; i < 5; i++){
522 <                Executors.invoke(p,r);
523 <            }
524 <            
525 <            shouldThrow();
526 <        } catch(ExecutionException success){
527 <        } catch(Exception e){
528 <            unexpectedException();
529 <        }
530 <        joinPool(p);
534 >    public void testCallable3() throws Exception {
535 >        Callable c = Executors.callable(new PrivilegedAction() {
536 >                public Object run() { return one; }});
537 >        assertSame(one, c.call());
538      }
539  
533
534
540      /**
541 <     *  invoke(Executor, Callable) throws InterruptedException if
537 <     *  callable throws exception
541 >     * callable(PrivilegedExceptionAction) returns its result when called
542       */
543 <    public void testInvoke5() {
544 <        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
545 <        
546 <        final Callable c = new Callable() {
543 <                public Object call() {
544 <                    try {
545 <                        Executors.invoke(p, new SmallCallable());
546 <                        shouldThrow();
547 <                    } catch(InterruptedException e){}
548 <                    catch(RejectedExecutionException e2){}
549 <                    catch(ExecutionException e3){}
550 <                    return Boolean.TRUE;
551 <                }
552 <            };
553 <
554 <
555 <        
556 <        Thread t = new Thread(new Runnable() {
557 <                public void run() {
558 <                    try {
559 <                        c.call();
560 <                    } catch(Exception e){}
561 <                }
562 <          });
563 <        try {
564 <            t.start();
565 <            Thread.sleep(SHORT_DELAY_MS);
566 <            t.interrupt();
567 <            t.join();
568 <        } catch(InterruptedException e){
569 <            unexpectedException();
570 <        }
571 <        
572 <        joinPool(p);
543 >    public void testCallable4() throws Exception {
544 >        Callable c = Executors.callable(new PrivilegedExceptionAction() {
545 >                public Object run() { return one; }});
546 >        assertSame(one, c.call());
547      }
548  
549      /**
550 <     *  invoke(Executor, Callable) will throw ExecutionException
577 <     *  if callable throws exception
550 >     * callable(null Runnable) throws NPE
551       */
552 <    public void testInvoke6() {
580 <        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
581 <
552 >    public void testCallableNPE1() {
553          try {
554 <            Callable c = new Callable() {
584 <                    public Object call() {
585 <                        int i = 5/0;
586 <                        return Boolean.TRUE;
587 <                    }
588 <                };
589 <            
590 <            for(int i =0; i < 5; i++){
591 <                Executors.invoke(p,c);
592 <            }
593 <            
554 >            Callable c = Executors.callable((Runnable) null);
555              shouldThrow();
556 <        }
596 <        catch(ExecutionException success){
597 <        } catch(Exception e) {
598 <            unexpectedException();
599 <        }
600 <        joinPool(p);
556 >        } catch (NullPointerException success) {}
557      }
558  
603
604
559      /**
560 <     *  timeouts from execute will time out if they compute too long.
560 >     * callable(null, result) throws NPE
561       */
562 <    public void testTimedCallable() {
609 <        int N = 10000;
610 <        ExecutorService executor = Executors.newSingleThreadExecutor();
611 <        List<Callable<BigInteger>> tasks = new ArrayList<Callable<BigInteger>>(N);
562 >    public void testCallableNPE2() {
563          try {
564 <            long startTime = System.currentTimeMillis();
565 <            
566 <            long i = 0;
616 <            while (tasks.size() < N) {
617 <                tasks.add(new TimedCallable<BigInteger>(executor, new Fib(i), 1));
618 <                i += 10;
619 <            }
620 <            
621 <            int iters = 0;
622 <            BigInteger sum = BigInteger.ZERO;
623 <            for (Iterator<Callable<BigInteger>> it = tasks.iterator(); it.hasNext();) {
624 <                try {
625 <                    ++iters;
626 <                    sum = sum.add(it.next().call());
627 <                }
628 <                catch (TimeoutException success) {
629 <                    assertTrue(iters > 0);
630 <                    return;
631 <                }
632 <                catch (Exception e) {
633 <                    unexpectedException();
634 <                }
635 <            }
636 <            // if by chance we didn't ever time out, total time must be small
637 <            long elapsed = System.currentTimeMillis() - startTime;
638 <            assertTrue(elapsed < N);
639 <        }
640 <        finally {
641 <            joinPool(executor);
642 <        }
564 >            Callable c = Executors.callable((Runnable) null, one);
565 >            shouldThrow();
566 >        } catch (NullPointerException success) {}
567      }
568  
645    
569      /**
570 <     * ThreadPoolExecutor using defaultThreadFactory has
648 <     * specified group, priority, daemon status, and name
570 >     * callable(null PrivilegedAction) throws NPE
571       */
572 <    public void testDefaultThreadFactory() {
573 <        final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
574 <        Runnable r = new Runnable() {
575 <                public void run() {
576 <                    Thread current = Thread.currentThread();
655 <                    threadAssertTrue(!current.isDaemon());
656 <                    threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
657 <                    ThreadGroup g = current.getThreadGroup();
658 <                    SecurityManager s = System.getSecurityManager();
659 <                    if (s != null)
660 <                        threadAssertTrue(g == s.getThreadGroup());
661 <                    else
662 <                        threadAssertTrue(g == egroup);
663 <                    String name = current.getName();
664 <                    threadAssertTrue(name.endsWith("thread-1"));
665 <                }
666 <            };
667 <        ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
668 <        
669 <        e.execute(r);
670 <        e.shutdown();
671 <        try {
672 <            Thread.sleep(SHORT_DELAY_MS);
673 <        } catch (Exception eX) {
674 <            unexpectedException();
675 <        } finally {
676 <            joinPool(e);
677 <        }
572 >    public void testCallableNPE3() {
573 >        try {
574 >            Callable c = Executors.callable((PrivilegedAction) null);
575 >            shouldThrow();
576 >        } catch (NullPointerException success) {}
577      }
578  
579      /**
580 <     * ThreadPoolExecutor using privilegedThreadFactory has
682 <     * specified group, priority, daemon status, name,
683 <     * access control context and context class loader
580 >     * callable(null PrivilegedExceptionAction) throws NPE
581       */
582 <    public void testPrivilegedThreadFactory() {
583 <        Policy savedPolicy = Policy.getPolicy();
584 <        AdjustablePolicy policy = new AdjustablePolicy();
585 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
586 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
690 <        Policy.setPolicy(policy);
691 <        final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
692 <        final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
693 <        final AccessControlContext thisacc = AccessController.getContext();
694 <        Runnable r = new Runnable() {
695 <                public void run() {
696 <                    Thread current = Thread.currentThread();
697 <                    threadAssertTrue(!current.isDaemon());
698 <                    threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
699 <                    ThreadGroup g = current.getThreadGroup();
700 <                    SecurityManager s = System.getSecurityManager();
701 <                    if (s != null)
702 <                        threadAssertTrue(g == s.getThreadGroup());
703 <                    else
704 <                        threadAssertTrue(g == egroup);
705 <                    String name = current.getName();
706 <                    threadAssertTrue(name.endsWith("thread-1"));
707 <                    threadAssertTrue(thisccl == current.getContextClassLoader());
708 <                    threadAssertTrue(thisacc.equals(AccessController.getContext()));
709 <                }
710 <            };
711 <        ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
712 <        
713 <        Policy.setPolicy(savedPolicy);
714 <        e.execute(r);
715 <        e.shutdown();
716 <        try {
717 <            Thread.sleep(SHORT_DELAY_MS);
718 <        } catch (Exception ex) {
719 <            unexpectedException();
720 <        } finally {
721 <            joinPool(e);
722 <        }
723 <
582 >    public void testCallableNPE4() {
583 >        try {
584 >            Callable c = Executors.callable((PrivilegedExceptionAction) null);
585 >            shouldThrow();
586 >        } catch (NullPointerException success) {}
587      }
588  
589   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines