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.24 by jsr166, Fri Nov 20 22:58:48 2009 UTC vs.
Revision 1.28 by jsr166, Wed Dec 2 19:17:01 2009 UTC

# Line 10 | Line 10
10   import junit.framework.*;
11   import java.util.*;
12   import java.util.concurrent.*;
13 + import static java.util.concurrent.TimeUnit.MILLISECONDS;
14   import java.math.BigInteger;
15   import java.security.*;
16  
# Line 21 | Line 22 | public class ExecutorsTest extends JSR16
22          return new TestSuite(ExecutorsTest.class);
23      }
24  
24 –    static class TimedCallable<T> implements Callable<T> {
25 –        private final ExecutorService exec;
26 –        private final Callable<T> func;
27 –        private final long msecs;
28 –
29 –        TimedCallable(ExecutorService exec, Callable<T> func, long msecs) {
30 –            this.exec = exec;
31 –            this.func = func;
32 –            this.msecs = msecs;
33 –        }
34 –
35 –        public T call() throws Exception {
36 –            Future<T> ftask = exec.submit(func);
37 –            try {
38 –                return ftask.get(msecs, TimeUnit.MILLISECONDS);
39 –            } finally {
40 –                ftask.cancel(true);
41 –            }
42 –        }
43 –    }
44 –
45 –
46 –    private static class Fib implements Callable<BigInteger> {
47 –        private final BigInteger n;
48 –        Fib(long n) {
49 –            if (n < 0) throw new IllegalArgumentException("need non-negative arg, but got " + n);
50 –            this.n = BigInteger.valueOf(n);
51 –        }
52 –        public BigInteger call() {
53 –            BigInteger f1 = BigInteger.ONE;
54 –            BigInteger f2 = f1;
55 –            for (BigInteger i = BigInteger.ZERO; i.compareTo(n) < 0; i = i.add(BigInteger.ONE)) {
56 –                BigInteger t = f1.add(f2);
57 –                f1 = f2;
58 –                f2 = t;
59 –            }
60 –            return f1;
61 –        }
62 –    };
63 –
25      /**
26       * A newCachedThreadPool can execute runnables
27       */
# Line 222 | Line 183 | public class ExecutorsTest extends JSR16
183      public void testNewSingleThreadScheduledExecutor() throws Exception {
184          TrackedCallable callable = new TrackedCallable();
185          ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
186 <        Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
186 >        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
187          assertFalse(callable.done);
188          Thread.sleep(MEDIUM_DELAY_MS);
189          assertTrue(callable.done);
# Line 236 | Line 197 | public class ExecutorsTest extends JSR16
197      public void testnewScheduledThreadPool() throws Exception {
198          TrackedCallable callable = new TrackedCallable();
199          ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
200 <        Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
200 >        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
201          assertFalse(callable.done);
202          Thread.sleep(MEDIUM_DELAY_MS);
203          assertTrue(callable.done);
# Line 250 | Line 211 | public class ExecutorsTest extends JSR16
211      public void testunconfigurableScheduledExecutorService() throws Exception {
212          TrackedCallable callable = new TrackedCallable();
213          ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
214 <        Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
214 >        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
215          assertFalse(callable.done);
216          Thread.sleep(MEDIUM_DELAY_MS);
217          assertTrue(callable.done);
# Line 259 | Line 220 | public class ExecutorsTest extends JSR16
220      }
221  
222      /**
223 <     *  timeouts from execute will time out if they compute too long.
223 >     *  Future.get on submitted tasks will time out if they compute too long.
224       */
225      public void testTimedCallable() throws Exception {
226 <        int N = 10000;
227 <        ExecutorService executor = Executors.newSingleThreadExecutor();
228 <        List<Callable<BigInteger>> tasks = new ArrayList<Callable<BigInteger>>(N);
229 <        try {
230 <            long startTime = System.currentTimeMillis();
231 <
232 <            long i = 0;
233 <            while (tasks.size() < N) {
234 <                tasks.add(new TimedCallable<BigInteger>(executor, new Fib(i), 1));
235 <                i += 10;
236 <            }
237 <
238 <            int iters = 0;
239 <            BigInteger sum = BigInteger.ZERO;
279 <            for (Iterator<Callable<BigInteger>> it = tasks.iterator(); it.hasNext();) {
226 >        final Runnable sleeper =
227 >            new RunnableShouldThrow(InterruptedException.class) {
228 >                public void realRun() throws InterruptedException {
229 >                    Thread.sleep(LONG_DELAY_MS);
230 >                }};
231 >        for (ExecutorService executor :
232 >                 new ExecutorService[] {
233 >                     Executors.newSingleThreadExecutor(),
234 >                     Executors.newCachedThreadPool(),
235 >                     Executors.newFixedThreadPool(2),
236 >                     Executors.newScheduledThreadPool(2),
237 >                 }) {
238 >            try {
239 >                Future future = executor.submit(sleeper);
240                  try {
241 <                    ++iters;
242 <                    sum = sum.add(it.next().call());
243 <                }
244 <                catch (TimeoutException success) {
245 <                    assertTrue(iters > 0);
286 <                    return;
241 >                    future.get(SHORT_DELAY_MS, MILLISECONDS);
242 >                    shouldThrow();
243 >                } catch (TimeoutException success) {
244 >                } finally {
245 >                    future.cancel(true);
246                  }
247              }
248 <            // if by chance we didn't ever time out, total time must be small
249 <            long elapsed = System.currentTimeMillis() - startTime;
250 <            assertTrue(elapsed < N);
292 <        }
293 <        finally {
294 <            joinPool(executor);
248 >            finally {
249 >                joinPool(executor);
250 >            }
251          }
252      }
253  
# Line 304 | Line 260 | public class ExecutorsTest extends JSR16
260          final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
261          Runnable r = new Runnable() {
262                  public void run() {
263 <                    try {
264 <                        Thread current = Thread.currentThread();
265 <                        threadAssertTrue(!current.isDaemon());
266 <                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
267 <                        ThreadGroup g = current.getThreadGroup();
268 <                        SecurityManager s = System.getSecurityManager();
269 <                        if (s != null)
270 <                            threadAssertTrue(g == s.getThreadGroup());
271 <                        else
272 <                            threadAssertTrue(g == egroup);
273 <                        String name = current.getName();
274 <                        threadAssertTrue(name.endsWith("thread-1"));
275 <                    } catch (SecurityException ok) {
276 <                        // Also pass if not allowed to change setting
277 <                    }
263 >                    try {
264 >                        Thread current = Thread.currentThread();
265 >                        threadAssertTrue(!current.isDaemon());
266 >                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
267 >                        ThreadGroup g = current.getThreadGroup();
268 >                        SecurityManager s = System.getSecurityManager();
269 >                        if (s != null)
270 >                            threadAssertTrue(g == s.getThreadGroup());
271 >                        else
272 >                            threadAssertTrue(g == egroup);
273 >                        String name = current.getName();
274 >                        threadAssertTrue(name.endsWith("thread-1"));
275 >                    } catch (SecurityException ok) {
276 >                        // Also pass if not allowed to change setting
277 >                    }
278                  }
279              };
280          ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
# Line 357 | Line 313 | public class ExecutorsTest extends JSR16
313          final AccessControlContext thisacc = AccessController.getContext();
314          Runnable r = new Runnable() {
315                  public void run() {
316 <                    try {
317 <                        Thread current = Thread.currentThread();
318 <                        threadAssertTrue(!current.isDaemon());
319 <                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
320 <                        ThreadGroup g = current.getThreadGroup();
321 <                        SecurityManager s = System.getSecurityManager();
322 <                        if (s != null)
323 <                            threadAssertTrue(g == s.getThreadGroup());
324 <                        else
325 <                            threadAssertTrue(g == egroup);
326 <                        String name = current.getName();
327 <                        threadAssertTrue(name.endsWith("thread-1"));
328 <                        threadAssertTrue(thisccl == current.getContextClassLoader());
329 <                        threadAssertTrue(thisacc.equals(AccessController.getContext()));
330 <                    } catch (SecurityException ok) {
331 <                        // Also pass if not allowed to change settings
332 <                    }
316 >                    try {
317 >                        Thread current = Thread.currentThread();
318 >                        threadAssertTrue(!current.isDaemon());
319 >                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
320 >                        ThreadGroup g = current.getThreadGroup();
321 >                        SecurityManager s = System.getSecurityManager();
322 >                        if (s != null)
323 >                            threadAssertTrue(g == s.getThreadGroup());
324 >                        else
325 >                            threadAssertTrue(g == egroup);
326 >                        String name = current.getName();
327 >                        threadAssertTrue(name.endsWith("thread-1"));
328 >                        threadAssertTrue(thisccl == current.getContextClassLoader());
329 >                        threadAssertTrue(thisacc.equals(AccessController.getContext()));
330 >                    } catch (SecurityException ok) {
331 >                        // Also pass if not allowed to change settings
332 >                    }
333                  }
334              };
335          ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
# Line 389 | Line 345 | public class ExecutorsTest extends JSR16
345          } finally {
346              joinPool(e);
347          }
392 –
348      }
349  
350      void checkCCL() {
# Line 413 | Line 368 | public class ExecutorsTest extends JSR16
368       * privilegedCallableUsingCurrentClassLoader throws ACE
369       */
370      public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
371 <        Policy savedPolicy = null;
371 >        Policy savedPolicy = null;
372          try {
373              savedPolicy = Policy.getPolicy();
374              AdjustablePolicy policy = new AdjustablePolicy();
# Line 445 | Line 400 | public class ExecutorsTest extends JSR16
400       * privilegedCallableUsingCurrentClassLoader does not throw ACE
401       */
402      public void testprivilegedCallableUsingCCLWithPrivs() throws Exception {
403 <        Policy savedPolicy = null;
403 >        Policy savedPolicy = null;
404          try {
405              savedPolicy = Policy.getPolicy();
406              AdjustablePolicy policy = new AdjustablePolicy();
# Line 506 | Line 461 | public class ExecutorsTest extends JSR16
461       * With permissions, calling privilegedCallable succeeds
462       */
463      public void testprivilegedCallableWithPrivs() throws Exception {
464 <        Policy savedPolicy = null;
464 >        Policy savedPolicy = null;
465          try {
466              savedPolicy = Policy.getPolicy();
467              AdjustablePolicy policy = new AdjustablePolicy();
# Line 538 | Line 493 | public class ExecutorsTest extends JSR16
493       */
494      public void testCallable2() throws Exception {
495          Callable c = Executors.callable(new NoOpRunnable(), one);
496 <        assertEquals(one, c.call());
496 >        assertSame(one, c.call());
497      }
498  
499      /**
# Line 547 | Line 502 | public class ExecutorsTest extends JSR16
502      public void testCallable3() throws Exception {
503          Callable c = Executors.callable(new PrivilegedAction() {
504                  public Object run() { return one; }});
505 <        assertEquals(one, c.call());
505 >        assertSame(one, c.call());
506      }
507  
508      /**
# Line 556 | Line 511 | public class ExecutorsTest extends JSR16
511      public void testCallable4() throws Exception {
512          Callable c = Executors.callable(new PrivilegedExceptionAction() {
513                  public Object run() { return one; }});
514 <        assertEquals(one, c.call());
514 >        assertSame(one, c.call());
515      }
516  
517  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines