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.30 by jsr166, Wed Aug 25 00:07:03 2010 UTC vs.
Revision 1.37 by jsr166, Tue Mar 15 19:47:06 2011 UTC

# Line 1 | Line 1
1   /*
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/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
# Line 181 | Line 181 | public class ExecutorsTest extends JSR16
181       * a newSingleThreadScheduledExecutor successfully runs delayed task
182       */
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, MILLISECONDS);
187 <        assertFalse(callable.done);
188 <        Thread.sleep(MEDIUM_DELAY_MS);
189 <        assertTrue(callable.done);
190 <        assertEquals(Boolean.TRUE, f.get());
191 <        joinPool(p1);
184 >        ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor();
185 >        try {
186 >            final CountDownLatch done = new CountDownLatch(1);
187 >            final Runnable task = new CheckedRunnable() {
188 >                public void realRun() {
189 >                    done.countDown();
190 >                }};
191 >            Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
192 >                                  SHORT_DELAY_MS, MILLISECONDS);
193 >            assertFalse(f.isDone());
194 >            assertTrue(done.await(MEDIUM_DELAY_MS, MILLISECONDS));
195 >            assertSame(Boolean.TRUE, f.get(SMALL_DELAY_MS, MILLISECONDS));
196 >            assertSame(Boolean.TRUE, f.get());
197 >            assertTrue(f.isDone());
198 >        } finally {
199 >            joinPool(p);
200 >        }
201      }
202  
203      /**
204       * a newScheduledThreadPool successfully runs delayed task
205       */
206      public void testnewScheduledThreadPool() throws Exception {
207 <        TrackedCallable callable = new TrackedCallable();
208 <        ScheduledExecutorService p1 = Executors.newScheduledThreadPool(2);
209 <        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
210 <        assertFalse(callable.done);
211 <        Thread.sleep(MEDIUM_DELAY_MS);
212 <        assertTrue(callable.done);
213 <        assertEquals(Boolean.TRUE, f.get());
214 <        joinPool(p1);
207 >        ScheduledExecutorService p = Executors.newScheduledThreadPool(2);
208 >        try {
209 >            final CountDownLatch done = new CountDownLatch(1);
210 >            final Runnable task = new CheckedRunnable() {
211 >                public void realRun() {
212 >                    done.countDown();
213 >                }};
214 >            Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
215 >                                  SHORT_DELAY_MS, MILLISECONDS);
216 >            assertFalse(f.isDone());
217 >            assertTrue(done.await(MEDIUM_DELAY_MS, MILLISECONDS));
218 >            assertSame(Boolean.TRUE, f.get(SMALL_DELAY_MS, MILLISECONDS));
219 >            assertSame(Boolean.TRUE, f.get());
220 >            assertTrue(f.isDone());
221 >        } finally {
222 >            joinPool(p);
223 >        }
224      }
225  
226      /**
227       * an unconfigurable newScheduledThreadPool successfully runs delayed task
228       */
229      public void testunconfigurableScheduledExecutorService() throws Exception {
230 <        TrackedCallable callable = new TrackedCallable();
231 <        ScheduledExecutorService p1 = Executors.unconfigurableScheduledExecutorService(Executors.newScheduledThreadPool(2));
232 <        Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
233 <        assertFalse(callable.done);
234 <        Thread.sleep(MEDIUM_DELAY_MS);
235 <        assertTrue(callable.done);
236 <        assertEquals(Boolean.TRUE, f.get());
237 <        joinPool(p1);
230 >        ScheduledExecutorService p =
231 >            Executors.unconfigurableScheduledExecutorService
232 >            (Executors.newScheduledThreadPool(2));
233 >        try {
234 >            final CountDownLatch done = new CountDownLatch(1);
235 >            final Runnable task = new CheckedRunnable() {
236 >                public void realRun() {
237 >                    done.countDown();
238 >                }};
239 >            Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
240 >                                  SHORT_DELAY_MS, MILLISECONDS);
241 >            assertFalse(f.isDone());
242 >            assertTrue(done.await(MEDIUM_DELAY_MS, MILLISECONDS));
243 >            assertSame(Boolean.TRUE, f.get(SMALL_DELAY_MS, MILLISECONDS));
244 >            assertSame(Boolean.TRUE, f.get());
245 >            assertTrue(f.isDone());
246 >        } finally {
247 >            joinPool(p);
248 >        }
249      }
250  
251      /**
252 <     *  Future.get on submitted tasks will time out if they compute too long.
252 >     * Future.get on submitted tasks will time out if they compute too long.
253       */
254      public void testTimedCallable() throws Exception {
255 <        final Runnable sleeper =
256 <            new RunnableShouldThrow(InterruptedException.class) {
257 <                public void realRun() throws InterruptedException {
258 <                    Thread.sleep(LONG_DELAY_MS);
230 <                }};
255 >        final Runnable sleeper = new CheckedInterruptedRunnable() {
256 >            public void realRun() throws InterruptedException {
257 >                Thread.sleep(LONG_DELAY_MS);
258 >            }};
259          for (ExecutorService executor :
260                   new ExecutorService[] {
261                       Executors.newSingleThreadExecutor(),
# Line 258 | Line 286 | public class ExecutorsTest extends JSR16
286       */
287      public void testDefaultThreadFactory() throws Exception {
288          final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
289 <        Runnable r = new Runnable() {
290 <                public void run() {
291 <                    try {
292 <                        Thread current = Thread.currentThread();
293 <                        threadAssertTrue(!current.isDaemon());
294 <                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
295 <                        ThreadGroup g = current.getThreadGroup();
296 <                        SecurityManager s = System.getSecurityManager();
297 <                        if (s != null)
298 <                            threadAssertTrue(g == s.getThreadGroup());
299 <                        else
300 <                            threadAssertTrue(g == egroup);
301 <                        String name = current.getName();
302 <                        threadAssertTrue(name.endsWith("thread-1"));
303 <                    } catch (SecurityException ok) {
304 <                        // Also pass if not allowed to change setting
277 <                    }
289 >        Runnable r = new CheckedRunnable() {
290 >            public void realRun() {
291 >                try {
292 >                    Thread current = Thread.currentThread();
293 >                    assertTrue(!current.isDaemon());
294 >                    assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
295 >                    ThreadGroup g = current.getThreadGroup();
296 >                    SecurityManager s = System.getSecurityManager();
297 >                    if (s != null)
298 >                        assertTrue(g == s.getThreadGroup());
299 >                    else
300 >                        assertTrue(g == egroup);
301 >                    String name = current.getName();
302 >                    assertTrue(name.endsWith("thread-1"));
303 >                } catch (SecurityException ok) {
304 >                    // Also pass if not allowed to change setting
305                  }
306 <            };
306 >            }};
307          ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
308  
309          e.execute(r);
# Line 316 | Line 343 | public class ExecutorsTest extends JSR16
343                              assertTrue(g == egroup);
344                          String name = current.getName();
345                          assertTrue(name.endsWith("thread-1"));
346 <                        assertTrue(thisccl == current.getContextClassLoader());
347 <                        assertTrue(thisacc.equals(AccessController.getContext()));
346 >                        assertSame(thisccl, current.getContextClassLoader());
347 >                        assertEquals(thisacc, AccessController.getContext());
348                      }};
349                  ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
350                  e.execute(r);
# Line 400 | Line 427 | public class ExecutorsTest extends JSR16
427       * Without permissions, calling privilegedCallable throws ACE
428       */
429      public void testprivilegedCallableWithNoPrivs() throws Exception {
430 +        // Avoid classloader-related SecurityExceptions in swingui.TestRunner
431 +        Executors.privilegedCallable(new CheckCCL());
432 +
433          Runnable r = new CheckedRunnable() {
434              public void realRun() throws Exception {
435                  if (System.getSecurityManager() == null)

Diff Legend

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