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.103 by jsr166, Mon Oct 5 22:19:00 2015 UTC vs.
Revision 1.107 by jsr166, Tue Oct 6 05:22:25 2015 UTC

# Line 113 | Line 113 | public class ThreadPoolExecutorTest exte
113                  public void realRun() throws InterruptedException {
114                      threadStarted.countDown();
115                      assertEquals(1, p.getActiveCount());
116 <                    done.await();
116 >                    await(done);
117                  }});
118              assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
119              assertEquals(1, p.getActiveCount());
# Line 341 | Line 341 | public class ThreadPoolExecutorTest exte
341                  p.execute(new CheckedRunnable() {
342                      public void realRun() throws InterruptedException {
343                          threadsStarted.countDown();
344 <                        done.await();
344 >                        await(done);
345                          assertEquals(THREADS, p.getLargestPoolSize());
346                      }});
347 <            assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
347 >            await(threadsStarted);
348              assertEquals(THREADS, p.getLargestPoolSize());
349          }
350          assertEquals(THREADS, p.getLargestPoolSize());
# Line 385 | Line 385 | public class ThreadPoolExecutorTest exte
385                  public void realRun() throws InterruptedException {
386                      threadStarted.countDown();
387                      assertEquals(1, p.getPoolSize());
388 <                    done.await();
388 >                    await(done);
389                  }});
390              assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
391              assertEquals(1, p.getPoolSize());
# Line 409 | Line 409 | public class ThreadPoolExecutorTest exte
409              p.execute(new CheckedRunnable() {
410                  public void realRun() throws InterruptedException {
411                      threadStarted.countDown();
412 <                    done.await();
412 >                    await(done);
413                  }});
414              assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
415              assertEquals(1, p.getTaskCount());
# Line 420 | Line 420 | public class ThreadPoolExecutorTest exte
420                      public void realRun() throws InterruptedException {
421                          threadStarted.countDown();
422                          assertEquals(1 + TASKS, p.getTaskCount());
423 <                        done.await();
423 >                        await(done);
424                      }});
425              }
426              assertEquals(1 + TASKS, p.getTaskCount());
# Line 493 | Line 493 | public class ThreadPoolExecutorTest exte
493                  public void realRun() throws InterruptedException {
494                      assertFalse(p.isTerminating());
495                      threadStarted.countDown();
496 <                    done.await();
496 >                    await(done);
497                  }});
498              assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
499              assertFalse(p.isTerminating());
# Line 521 | Line 521 | public class ThreadPoolExecutorTest exte
521                  public void realRun() throws InterruptedException {
522                      assertFalse(p.isTerminating());
523                      threadStarted.countDown();
524 <                    done.await();
524 >                    await(done);
525                  }});
526              assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
527              assertFalse(p.isTerminating());
# Line 551 | Line 551 | public class ThreadPoolExecutorTest exte
551                      public Boolean realCall() throws InterruptedException {
552                          threadStarted.countDown();
553                          assertSame(q, p.getQueue());
554 <                        done.await();
554 >                        await(done);
555                          return Boolean.TRUE;
556                      }};
557                  tasks[i] = new FutureTask(task);
# Line 583 | Line 583 | public class ThreadPoolExecutorTest exte
583                  tasks[i] = new CheckedRunnable() {
584                      public void realRun() throws InterruptedException {
585                          threadStarted.countDown();
586 <                        done.await();
586 >                        await(done);
587                      }};
588                  p.execute(tasks[i]);
589              }
# Line 618 | Line 618 | public class ThreadPoolExecutorTest exte
618                  Callable task = new CheckedCallable<Boolean>() {
619                      public Boolean realCall() throws InterruptedException {
620                          threadStarted.countDown();
621 <                        done.await();
621 >                        await(done);
622                          return Boolean.TRUE;
623                      }};
624                  tasks[i] = new FutureTask(task);
# Line 662 | Line 662 | public class ThreadPoolExecutorTest exte
662          }};
663          for (int i = 0; i < count; i++)
664              p.execute(waiter);
665 <        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
665 >        await(threadsStarted);
666          assertEquals(poolSize, p.getActiveCount());
667          assertEquals(0, p.getCompletedTaskCount());
668          final List<Runnable> queuedTasks;
# Line 1024 | Line 1024 | public class ThreadPoolExecutorTest exte
1024       * get of submitted callable throws InterruptedException if interrupted
1025       */
1026      public void testInterruptedSubmit() throws InterruptedException {
1027 +        final CountDownLatch done = new CountDownLatch(1);
1028          final ThreadPoolExecutor p =
1029              new ThreadPoolExecutor(1, 1,
1030                                     60, SECONDS,
1031                                     new ArrayBlockingQueue<Runnable>(10));
1032  
1033 <        try (PoolCleaner cleaner = cleaner(p)) {
1033 >        try (PoolCleaner cleaner = cleaner(p, done)) {
1034              final CountDownLatch threadStarted = new CountDownLatch(1);
1034 –            final CountDownLatch done = new CountDownLatch(1);
1035              Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1036                  public void realRun() throws Exception {
1037                      Callable task = new CheckedCallable<Boolean>() {
1038                          public Boolean realCall() throws InterruptedException {
1039                              threadStarted.countDown();
1040 <                            done.await();
1040 >                            await(done);
1041                              return Boolean.TRUE;
1042                          }};
1043                      p.submit(task).get();
1044                  }});
1045  
1046 <            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
1046 >            await(threadStarted);
1047              t.interrupt();
1048 <            awaitTermination(t, MEDIUM_DELAY_MS);
1049 <            done.countDown();
1048 >            awaitTermination(t);
1049          }
1050      }
1051  
# Line 1062 | Line 1061 | public class ThreadPoolExecutorTest exte
1061              final CountDownLatch done = new CountDownLatch(1);
1062              Runnable task = new CheckedRunnable() {
1063                  public void realRun() throws InterruptedException {
1064 <                    done.await();
1064 >                    await(done);
1065                  }};
1066              for (int i = 0; i < 2; ++i)
1067                  p.execute(task);
# Line 1089 | Line 1088 | public class ThreadPoolExecutorTest exte
1088              final CountDownLatch done = new CountDownLatch(1);
1089              Runnable task = new CheckedRunnable() {
1090                  public void realRun() throws InterruptedException {
1091 <                    done.await();
1091 >                    await(done);
1092                  }};
1093              for (int i = 0; i < 2; ++i)
1094                  p.submit(task);
# Line 1116 | Line 1115 | public class ThreadPoolExecutorTest exte
1115              final CountDownLatch done = new CountDownLatch(1);
1116              Runnable task = new CheckedRunnable() {
1117                  public void realRun() throws InterruptedException {
1118 <                    done.await();
1118 >                    await(done);
1119                  }};
1120              for (int i = 0; i < 2; ++i)
1121                  p.submit(Executors.callable(task));
# Line 1145 | Line 1144 | public class ThreadPoolExecutorTest exte
1144              final CountDownLatch done = new CountDownLatch(1);
1145              Runnable blocker = new CheckedRunnable() {
1146                  public void realRun() throws InterruptedException {
1147 <                    done.await();
1147 >                    await(done);
1148                  }};
1149              p.execute(blocker);
1150              TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
# Line 1844 | Line 1843 | public class ThreadPoolExecutorTest exte
1843              List<Callable<String>> l = new ArrayList<Callable<String>>();
1844              l.add(new NPETask());
1845              List<Future<String>> futures =
1846 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1846 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1847              assertEquals(1, futures.size());
1848              try {
1849                  futures.get(0).get();

Diff Legend

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