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.115 by jsr166, Mon Mar 20 00:21:54 2017 UTC vs.
Revision 1.120 by jsr166, Sat Jul 15 18:17:40 2017 UTC

# Line 11 | Line 11 | import static java.util.concurrent.TimeU
11   import static java.util.concurrent.TimeUnit.SECONDS;
12  
13   import java.util.ArrayList;
14 + import java.util.Collection;
15 + import java.util.Collections;
16   import java.util.List;
17   import java.util.concurrent.ArrayBlockingQueue;
18   import java.util.concurrent.BlockingQueue;
# Line 90 | Line 92 | public class ThreadPoolExecutorTest exte
92              final Runnable task = new CheckedRunnable() {
93                  public void realRun() { done.countDown(); }};
94              p.execute(task);
95 <            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
95 >            await(done);
96          }
97      }
98  
# Line 184 | Line 186 | public class ThreadPoolExecutorTest exte
186                  public void realRun() throws InterruptedException {
187                      threadStarted.countDown();
188                      assertEquals(0, p.getCompletedTaskCount());
189 <                    threadProceed.await();
189 >                    await(threadProceed);
190                      threadDone.countDown();
191                  }});
192              await(threadStarted);
193              assertEquals(0, p.getCompletedTaskCount());
194              threadProceed.countDown();
195 <            threadDone.await();
195 >            await(threadDone);
196              long startTime = System.nanoTime();
197              while (p.getCompletedTaskCount() != 1) {
198                  if (millisElapsedSince(startTime) > LONG_DELAY_MS)
# Line 274 | Line 276 | public class ThreadPoolExecutorTest exte
276      }
277  
278      /**
279 +     * The default rejected execution handler is AbortPolicy.
280 +     */
281 +    public void testDefaultRejectedExecutionHandler() {
282 +        final ThreadPoolExecutor p =
283 +            new ThreadPoolExecutor(1, 2,
284 +                                   LONG_DELAY_MS, MILLISECONDS,
285 +                                   new ArrayBlockingQueue<Runnable>(10));
286 +        try (PoolCleaner cleaner = cleaner(p)) {
287 +            assertTrue(p.getRejectedExecutionHandler()
288 +                       instanceof ThreadPoolExecutor.AbortPolicy);
289 +        }
290 +    }
291 +
292 +    /**
293       * getRejectedExecutionHandler returns handler in constructor if not set
294       */
295      public void testGetRejectedExecutionHandler() {
# Line 456 | Line 472 | public class ThreadPoolExecutorTest exte
472              assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
473              assertFalse(p.awaitTermination(-1L, NANOSECONDS));
474              assertFalse(p.awaitTermination(-1L, MILLISECONDS));
475 <            assertFalse(p.awaitTermination(0L, NANOSECONDS));
476 <            assertFalse(p.awaitTermination(0L, MILLISECONDS));
475 >            assertFalse(p.awaitTermination(randomExpiredTimeout(),
476 >                                           randomTimeUnit()));
477              long timeoutNanos = 999999L;
478              long startTime = System.nanoTime();
479              assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
# Line 1481 | Line 1497 | public class ThreadPoolExecutorTest exte
1497      }
1498  
1499      /**
1500 <     * invokeAny(empty collection) throws IAE
1500 >     * invokeAny(empty collection) throws IllegalArgumentException
1501       */
1502      public void testInvokeAny2() throws Exception {
1503          final ExecutorService e =
# Line 1571 | Line 1587 | public class ThreadPoolExecutorTest exte
1587      }
1588  
1589      /**
1590 <     * invokeAll(empty collection) returns empty collection
1590 >     * invokeAll(empty collection) returns empty list
1591       */
1592      public void testInvokeAll2() throws InterruptedException {
1593          final ExecutorService e =
1594              new ThreadPoolExecutor(2, 2,
1595                                     LONG_DELAY_MS, MILLISECONDS,
1596                                     new ArrayBlockingQueue<Runnable>(10));
1597 +        final Collection<Callable<String>> emptyCollection
1598 +            = Collections.emptyList();
1599          try (PoolCleaner cleaner = cleaner(e)) {
1600 <            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1600 >            List<Future<String>> r = e.invokeAll(emptyCollection);
1601              assertTrue(r.isEmpty());
1602          }
1603      }
# Line 1654 | Line 1672 | public class ThreadPoolExecutorTest exte
1672                                     new ArrayBlockingQueue<Runnable>(10));
1673          try (PoolCleaner cleaner = cleaner(e)) {
1674              try {
1675 <                e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1675 >                e.invokeAny(null, randomTimeout(), randomTimeUnit());
1676                  shouldThrow();
1677              } catch (NullPointerException success) {}
1678          }
# Line 1672 | Line 1690 | public class ThreadPoolExecutorTest exte
1690              List<Callable<String>> l = new ArrayList<>();
1691              l.add(new StringTask());
1692              try {
1693 <                e.invokeAny(l, MEDIUM_DELAY_MS, null);
1693 >                e.invokeAny(l, randomTimeout(), null);
1694                  shouldThrow();
1695              } catch (NullPointerException success) {}
1696          }
1697      }
1698  
1699      /**
1700 <     * timed invokeAny(empty collection) throws IAE
1700 >     * timed invokeAny(empty collection) throws IllegalArgumentException
1701       */
1702      public void testTimedInvokeAny2() throws Exception {
1703          final ExecutorService e =
# Line 1689 | Line 1707 | public class ThreadPoolExecutorTest exte
1707          try (PoolCleaner cleaner = cleaner(e)) {
1708              try {
1709                  e.invokeAny(new ArrayList<Callable<String>>(),
1710 <                            MEDIUM_DELAY_MS, MILLISECONDS);
1710 >                            randomTimeout(), randomTimeUnit());
1711                  shouldThrow();
1712              } catch (IllegalArgumentException success) {}
1713          }
1714      }
1715  
1716      /**
1717 <     * timed invokeAny(c) throws NPE if c has null elements
1717 >     * timed invokeAny(c) throws NullPointerException if c has null elements
1718       */
1719      public void testTimedInvokeAny3() throws Exception {
1720          final CountDownLatch latch = new CountDownLatch(1);
# Line 1709 | Line 1727 | public class ThreadPoolExecutorTest exte
1727              l.add(latchAwaitingStringTask(latch));
1728              l.add(null);
1729              try {
1730 <                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1730 >                e.invokeAny(l, randomTimeout(), randomTimeUnit());
1731                  shouldThrow();
1732              } catch (NullPointerException success) {}
1733              latch.countDown();
# Line 1767 | Line 1785 | public class ThreadPoolExecutorTest exte
1785                                     new ArrayBlockingQueue<Runnable>(10));
1786          try (PoolCleaner cleaner = cleaner(e)) {
1787              try {
1788 <                e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1788 >                e.invokeAll(null, randomTimeout(), randomTimeUnit());
1789                  shouldThrow();
1790              } catch (NullPointerException success) {}
1791          }
# Line 1785 | Line 1803 | public class ThreadPoolExecutorTest exte
1803              List<Callable<String>> l = new ArrayList<>();
1804              l.add(new StringTask());
1805              try {
1806 <                e.invokeAll(l, MEDIUM_DELAY_MS, null);
1806 >                e.invokeAll(l, randomTimeout(), null);
1807                  shouldThrow();
1808              } catch (NullPointerException success) {}
1809          }
1810      }
1811  
1812      /**
1813 <     * timed invokeAll(empty collection) returns empty collection
1813 >     * timed invokeAll(empty collection) returns empty list
1814       */
1815      public void testTimedInvokeAll2() throws InterruptedException {
1816          final ExecutorService e =
1817              new ThreadPoolExecutor(2, 2,
1818                                     LONG_DELAY_MS, MILLISECONDS,
1819                                     new ArrayBlockingQueue<Runnable>(10));
1820 +        final Collection<Callable<String>> emptyCollection
1821 +            = Collections.emptyList();
1822          try (PoolCleaner cleaner = cleaner(e)) {
1823 <            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(),
1824 <                                                 MEDIUM_DELAY_MS, MILLISECONDS);
1823 >            List<Future<String>> r =
1824 >                e.invokeAll(emptyCollection, randomTimeout(), randomTimeUnit());
1825              assertTrue(r.isEmpty());
1826          }
1827      }
# Line 1819 | Line 1839 | public class ThreadPoolExecutorTest exte
1839              l.add(new StringTask());
1840              l.add(null);
1841              try {
1842 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1842 >                e.invokeAll(l, randomTimeout(), randomTimeUnit());
1843                  shouldThrow();
1844              } catch (NullPointerException success) {}
1845          }
# Line 1927 | Line 1947 | public class ThreadPoolExecutorTest exte
1947                      public void realRun() {
1948                          done.countDown();
1949                      }});
1950 <            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
1950 >            await(done);
1951          }
1952      }
1953  
# Line 2020 | Line 2040 | public class ThreadPoolExecutorTest exte
2040                  }
2041              }
2042              // enough time to run all tasks
2043 <            assertTrue(done.await(nTasks * SHORT_DELAY_MS, MILLISECONDS));
2043 >            await(done, nTasks * SHORT_DELAY_MS);
2044          }
2045      }
2046  
# Line 2061 | Line 2081 | public class ThreadPoolExecutorTest exte
2081          }
2082      }
2083  
2084 +    public void testAbortPolicy() {
2085 +        final RejectedExecutionHandler handler =
2086 +            new ThreadPoolExecutor.AbortPolicy();
2087 +        final ThreadPoolExecutor p =
2088 +            new ThreadPoolExecutor(1, 1,
2089 +                                   LONG_DELAY_MS, MILLISECONDS,
2090 +                                   new ArrayBlockingQueue<Runnable>(10));
2091 +        final TrackedNoOpRunnable r = new TrackedNoOpRunnable();
2092 +        try {
2093 +            handler.rejectedExecution(r, p);
2094 +            shouldThrow();
2095 +        } catch (RejectedExecutionException success) {}
2096 +        assertFalse(r.done);
2097 +        assertEquals(0, p.getTaskCount());
2098 +        assertTrue(p.getQueue().isEmpty());
2099 +    }
2100 +
2101   }

Diff Legend

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