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

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.73 by jsr166, Sun Oct 4 01:56:51 2015 UTC vs.
Revision 1.78 by jsr166, Sun Oct 4 02:09:57 2015 UTC

# Line 306 | Line 306 | public class ThreadPoolExecutorTest exte
306              new ThreadPoolExecutor(1, 2,
307                                     LONG_DELAY_MS, MILLISECONDS,
308                                     new ArrayBlockingQueue<Runnable>(10));
309 <        RejectedExecutionHandler h = new NoOpREHandler();
310 <        p.setRejectedExecutionHandler(h);
311 <        assertSame(h, p.getRejectedExecutionHandler());
312 <        joinPool(p);
309 >        try (PoolCleaner cleaner = cleaner(p)) {
310 >            RejectedExecutionHandler handler = new NoOpREHandler();
311 >            p.setRejectedExecutionHandler(handler);
312 >            assertSame(handler, p.getRejectedExecutionHandler());
313 >        }
314      }
315  
316      /**
# Line 320 | Line 321 | public class ThreadPoolExecutorTest exte
321              new ThreadPoolExecutor(1, 2,
322                                     LONG_DELAY_MS, MILLISECONDS,
323                                     new ArrayBlockingQueue<Runnable>(10));
324 <        try {
325 <            p.setRejectedExecutionHandler(null);
326 <            shouldThrow();
327 <        } catch (NullPointerException success) {
328 <        } finally {
328 <            joinPool(p);
324 >        try (PoolCleaner cleaner = cleaner(p)) {
325 >            try {
326 >                p.setRejectedExecutionHandler(null);
327 >                shouldThrow();
328 >            } catch (NullPointerException success) {}
329          }
330      }
331  
# Line 339 | Line 339 | public class ThreadPoolExecutorTest exte
339              new ThreadPoolExecutor(THREADS, THREADS,
340                                     LONG_DELAY_MS, MILLISECONDS,
341                                     new ArrayBlockingQueue<Runnable>(10));
342 <        final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
343 <        final CountDownLatch done = new CountDownLatch(1);
344 <        try {
342 >        try (PoolCleaner cleaner = cleaner(p)) {
343 >            final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
344 >            final CountDownLatch done = new CountDownLatch(1);
345              assertEquals(0, p.getLargestPoolSize());
346              for (int i = 0; i < THREADS; i++)
347                  p.execute(new CheckedRunnable() {
# Line 350 | Line 350 | public class ThreadPoolExecutorTest exte
350                          done.await();
351                          assertEquals(THREADS, p.getLargestPoolSize());
352                      }});
353 <            assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS));
354 <            assertEquals(THREADS, p.getLargestPoolSize());
355 <        } finally {
356 <            done.countDown();
357 <            joinPool(p);
353 >            assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
354              assertEquals(THREADS, p.getLargestPoolSize());
355 +            done.countDown();   // release pool
356          }
357 +        assertEquals(THREADS, p.getLargestPoolSize());
358      }
359  
360      /**
# Line 368 | Line 366 | public class ThreadPoolExecutorTest exte
366              new ThreadPoolExecutor(2, 3,
367                                     LONG_DELAY_MS, MILLISECONDS,
368                                     new ArrayBlockingQueue<Runnable>(10));
369 <        assertEquals(3, p.getMaximumPoolSize());
370 <        joinPool(p);
369 >        try (PoolCleaner cleaner = cleaner(p)) {
370 >            assertEquals(3, p.getMaximumPoolSize());
371 >            p.setMaximumPoolSize(5);
372 >            assertEquals(5, p.getMaximumPoolSize());
373 >            p.setMaximumPoolSize(4);
374 >            assertEquals(4, p.getMaximumPoolSize());
375 >        }
376      }
377  
378      /**
# Line 381 | Line 384 | public class ThreadPoolExecutorTest exte
384              new ThreadPoolExecutor(1, 1,
385                                     LONG_DELAY_MS, MILLISECONDS,
386                                     new ArrayBlockingQueue<Runnable>(10));
387 <        final CountDownLatch threadStarted = new CountDownLatch(1);
388 <        final CountDownLatch done = new CountDownLatch(1);
389 <        try {
387 >        try (PoolCleaner cleaner = cleaner(p)) {
388 >            final CountDownLatch threadStarted = new CountDownLatch(1);
389 >            final CountDownLatch done = new CountDownLatch(1);
390              assertEquals(0, p.getPoolSize());
391              p.execute(new CheckedRunnable() {
392                  public void realRun() throws InterruptedException {
# Line 391 | Line 394 | public class ThreadPoolExecutorTest exte
394                      assertEquals(1, p.getPoolSize());
395                      done.await();
396                  }});
397 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
397 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
398              assertEquals(1, p.getPoolSize());
399 <        } finally {
397 <            done.countDown();
398 <            joinPool(p);
399 >            done.countDown();   // release pool
400          }
401      }
402  

Diff Legend

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