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.23 by jsr166, Thu Nov 19 03:55:29 2009 UTC vs.
Revision 1.27 by jsr166, Tue Dec 1 09:56:28 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 35 | Line 36 | public class ExecutorsTest extends JSR16
36          public T call() throws Exception {
37              Future<T> ftask = exec.submit(func);
38              try {
39 <                return ftask.get(msecs, TimeUnit.MILLISECONDS);
39 >                return ftask.get(msecs, MILLISECONDS);
40              } finally {
41                  ftask.cancel(true);
42              }
# Line 220 | Line 221 | public class ExecutorsTest extends JSR16
221       * a newSingleThreadScheduledExecutor successfully runs delayed task
222       */
223      public void testNewSingleThreadScheduledExecutor() throws Exception {
224 <        try {
225 <            TrackedCallable callable = new TrackedCallable();
226 <            ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
227 <            Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
228 <            assertFalse(callable.done);
229 <            Thread.sleep(MEDIUM_DELAY_MS);
230 <            assertTrue(callable.done);
231 <            assertEquals(Boolean.TRUE, f.get());
231 <            joinPool(p1);
232 <        } catch (RejectedExecutionException e) {}
224 >        TrackedCallable callable = new TrackedCallable();
225 >        ScheduledExecutorService p1 = Executors.newSingleThreadScheduledExecutor();
226 >        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
227 >        assertFalse(callable.done);
228 >        Thread.sleep(MEDIUM_DELAY_MS);
229 >        assertTrue(callable.done);
230 >        assertEquals(Boolean.TRUE, f.get());
231 >        joinPool(p1);
232      }
233  
234      /**
235       * a newScheduledThreadPool successfully runs delayed task
236       */
237      public void testnewScheduledThreadPool() throws Exception {
238 <        try {
239 <            TrackedCallable callable = new TrackedCallable();
240 <            ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
241 <            Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
242 <            assertFalse(callable.done);
243 <            Thread.sleep(MEDIUM_DELAY_MS);
244 <            assertTrue(callable.done);
245 <            assertEquals(Boolean.TRUE, f.get());
247 <            joinPool(p1);
248 <        } catch (RejectedExecutionException e) {}
238 >        TrackedCallable callable = new TrackedCallable();
239 >        ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
240 >        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
241 >        assertFalse(callable.done);
242 >        Thread.sleep(MEDIUM_DELAY_MS);
243 >        assertTrue(callable.done);
244 >        assertEquals(Boolean.TRUE, f.get());
245 >        joinPool(p1);
246      }
247  
248      /**
249 <     * an unconfigurable  newScheduledThreadPool successfully runs delayed task
249 >     * an unconfigurable newScheduledThreadPool successfully runs delayed task
250       */
251      public void testunconfigurableScheduledExecutorService() throws Exception {
252 <        try {
253 <            TrackedCallable callable = new TrackedCallable();
254 <            ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
255 <            Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
256 <            assertFalse(callable.done);
257 <            Thread.sleep(MEDIUM_DELAY_MS);
258 <            assertTrue(callable.done);
259 <            assertEquals(Boolean.TRUE, f.get());
263 <            joinPool(p1);
264 <        } catch (RejectedExecutionException e) {}
252 >        TrackedCallable callable = new TrackedCallable();
253 >        ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
254 >        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
255 >        assertFalse(callable.done);
256 >        Thread.sleep(MEDIUM_DELAY_MS);
257 >        assertTrue(callable.done);
258 >        assertEquals(Boolean.TRUE, f.get());
259 >        joinPool(p1);
260      }
261  
262      /**
# Line 310 | Line 305 | public class ExecutorsTest extends JSR16
305          final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
306          Runnable r = new Runnable() {
307                  public void run() {
308 <                    try {
309 <                        Thread current = Thread.currentThread();
310 <                        threadAssertTrue(!current.isDaemon());
311 <                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
312 <                        ThreadGroup g = current.getThreadGroup();
313 <                        SecurityManager s = System.getSecurityManager();
314 <                        if (s != null)
315 <                            threadAssertTrue(g == s.getThreadGroup());
316 <                        else
317 <                            threadAssertTrue(g == egroup);
318 <                        String name = current.getName();
319 <                        threadAssertTrue(name.endsWith("thread-1"));
320 <                    } catch (SecurityException ok) {
321 <                        // Also pass if not allowed to change setting
322 <                    }
308 >                    try {
309 >                        Thread current = Thread.currentThread();
310 >                        threadAssertTrue(!current.isDaemon());
311 >                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
312 >                        ThreadGroup g = current.getThreadGroup();
313 >                        SecurityManager s = System.getSecurityManager();
314 >                        if (s != null)
315 >                            threadAssertTrue(g == s.getThreadGroup());
316 >                        else
317 >                            threadAssertTrue(g == egroup);
318 >                        String name = current.getName();
319 >                        threadAssertTrue(name.endsWith("thread-1"));
320 >                    } catch (SecurityException ok) {
321 >                        // Also pass if not allowed to change setting
322 >                    }
323                  }
324              };
325          ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
# Line 363 | Line 358 | public class ExecutorsTest extends JSR16
358          final AccessControlContext thisacc = AccessController.getContext();
359          Runnable r = new Runnable() {
360                  public void run() {
361 <                    try {
362 <                        Thread current = Thread.currentThread();
363 <                        threadAssertTrue(!current.isDaemon());
364 <                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
365 <                        ThreadGroup g = current.getThreadGroup();
366 <                        SecurityManager s = System.getSecurityManager();
367 <                        if (s != null)
368 <                            threadAssertTrue(g == s.getThreadGroup());
369 <                        else
370 <                            threadAssertTrue(g == egroup);
371 <                        String name = current.getName();
372 <                        threadAssertTrue(name.endsWith("thread-1"));
373 <                        threadAssertTrue(thisccl == current.getContextClassLoader());
374 <                        threadAssertTrue(thisacc.equals(AccessController.getContext()));
375 <                    } catch (SecurityException ok) {
376 <                        // Also pass if not allowed to change settings
377 <                    }
361 >                    try {
362 >                        Thread current = Thread.currentThread();
363 >                        threadAssertTrue(!current.isDaemon());
364 >                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
365 >                        ThreadGroup g = current.getThreadGroup();
366 >                        SecurityManager s = System.getSecurityManager();
367 >                        if (s != null)
368 >                            threadAssertTrue(g == s.getThreadGroup());
369 >                        else
370 >                            threadAssertTrue(g == egroup);
371 >                        String name = current.getName();
372 >                        threadAssertTrue(name.endsWith("thread-1"));
373 >                        threadAssertTrue(thisccl == current.getContextClassLoader());
374 >                        threadAssertTrue(thisacc.equals(AccessController.getContext()));
375 >                    } catch (SecurityException ok) {
376 >                        // Also pass if not allowed to change settings
377 >                    }
378                  }
379              };
380          ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
# Line 395 | Line 390 | public class ExecutorsTest extends JSR16
390          } finally {
391              joinPool(e);
392          }
398 –
393      }
394  
395      void checkCCL() {
# Line 419 | Line 413 | public class ExecutorsTest extends JSR16
413       * privilegedCallableUsingCurrentClassLoader throws ACE
414       */
415      public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
416 <        Policy savedPolicy = null;
416 >        Policy savedPolicy = null;
417          try {
418              savedPolicy = Policy.getPolicy();
419              AdjustablePolicy policy = new AdjustablePolicy();
# Line 451 | Line 445 | public class ExecutorsTest extends JSR16
445       * privilegedCallableUsingCurrentClassLoader does not throw ACE
446       */
447      public void testprivilegedCallableUsingCCLWithPrivs() throws Exception {
448 <        Policy savedPolicy = null;
448 >        Policy savedPolicy = null;
449          try {
450              savedPolicy = Policy.getPolicy();
451              AdjustablePolicy policy = new AdjustablePolicy();
# Line 512 | Line 506 | public class ExecutorsTest extends JSR16
506       * With permissions, calling privilegedCallable succeeds
507       */
508      public void testprivilegedCallableWithPrivs() throws Exception {
509 <        Policy savedPolicy = null;
509 >        Policy savedPolicy = null;
510          try {
511              savedPolicy = Policy.getPolicy();
512              AdjustablePolicy policy = new AdjustablePolicy();
# Line 544 | Line 538 | public class ExecutorsTest extends JSR16
538       */
539      public void testCallable2() throws Exception {
540          Callable c = Executors.callable(new NoOpRunnable(), one);
541 <        assertEquals(one, c.call());
541 >        assertSame(one, c.call());
542      }
543  
544      /**
# Line 553 | Line 547 | public class ExecutorsTest extends JSR16
547      public void testCallable3() throws Exception {
548          Callable c = Executors.callable(new PrivilegedAction() {
549                  public Object run() { return one; }});
550 <        assertEquals(one, c.call());
550 >        assertSame(one, c.call());
551      }
552  
553      /**
# Line 562 | Line 556 | public class ExecutorsTest extends JSR16
556      public void testCallable4() throws Exception {
557          Callable c = Executors.callable(new PrivilegedExceptionAction() {
558                  public Object run() { return one; }});
559 <        assertEquals(one, c.call());
559 >        assertSame(one, c.call());
560      }
561  
562  

Diff Legend

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