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

Comparing jsr166/src/test/tck/ScheduledExecutorSubclassTest.java (file contents):
Revision 1.52 by jsr166, Tue Oct 6 05:12:16 2015 UTC vs.
Revision 1.56 by jsr166, Tue Oct 6 16:39:06 2015 UTC

# Line 437 | Line 437 | public class ScheduledExecutorSubclassTe
437                          await(done);
438                          assertEquals(THREADS, p.getLargestPoolSize());
439                      }});
440 <            assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
440 >            await(threadsStarted);
441              assertEquals(THREADS, p.getLargestPoolSize());
442          }
443          assertEquals(THREADS, p.getLargestPoolSize());
# Line 587 | Line 587 | public class ScheduledExecutorSubclassTe
587                      threadStarted.countDown();
588                      await(done);
589                  }});
590 <            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
590 >            await(threadStarted);
591              assertFalse(p.isTerminating());
592              done.countDown();
593              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 601 | Line 601 | public class ScheduledExecutorSubclassTe
601       * getQueue returns the work queue, which contains queued tasks
602       */
603      public void testGetQueue() throws InterruptedException {
604 +        final CountDownLatch done = new CountDownLatch(1);
605          final ScheduledThreadPoolExecutor p = new CustomExecutor(1);
606 <        try (PoolCleaner cleaner = cleaner(p)) {
606 >        try (PoolCleaner cleaner = cleaner(p, done)) {
607              final CountDownLatch threadStarted = new CountDownLatch(1);
607 –            final CountDownLatch done = new CountDownLatch(1);
608              ScheduledFuture[] tasks = new ScheduledFuture[5];
609              for (int i = 0; i < tasks.length; i++) {
610                  Runnable r = new CheckedRunnable() {
# Line 614 | Line 614 | public class ScheduledExecutorSubclassTe
614                      }};
615                  tasks[i] = p.schedule(r, 1, MILLISECONDS);
616              }
617 <            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
617 >            await(threadStarted);
618              BlockingQueue<Runnable> q = p.getQueue();
619              assertTrue(q.contains(tasks[tasks.length - 1]));
620              assertFalse(q.contains(tasks[0]));
621 –            done.countDown();
621          }
622      }
623  
# Line 626 | Line 625 | public class ScheduledExecutorSubclassTe
625       * remove(task) removes queued task, and fails to remove active task
626       */
627      public void testRemove() throws InterruptedException {
628 +        final CountDownLatch done = new CountDownLatch(1);
629          final ScheduledThreadPoolExecutor p = new CustomExecutor(1);
630 <        try (PoolCleaner cleaner = cleaner(p)) {
630 >        try (PoolCleaner cleaner = cleaner(p, done)) {
631              ScheduledFuture[] tasks = new ScheduledFuture[5];
632              final CountDownLatch threadStarted = new CountDownLatch(1);
633 –            final CountDownLatch done = new CountDownLatch(1);
633              for (int i = 0; i < tasks.length; i++) {
634                  Runnable r = new CheckedRunnable() {
635                      public void realRun() throws InterruptedException {
# Line 639 | Line 638 | public class ScheduledExecutorSubclassTe
638                      }};
639                  tasks[i] = p.schedule(r, 1, MILLISECONDS);
640              }
641 <            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
641 >            await(threadStarted);
642              BlockingQueue<Runnable> q = p.getQueue();
643              assertFalse(p.remove((Runnable)tasks[0]));
644              assertTrue(q.contains((Runnable)tasks[4]));
# Line 650 | Line 649 | public class ScheduledExecutorSubclassTe
649              assertTrue(q.contains((Runnable)tasks[3]));
650              assertTrue(p.remove((Runnable)tasks[3]));
651              assertFalse(q.contains((Runnable)tasks[3]));
653 –            done.countDown();
652          }
653      }
654  
# Line 702 | Line 700 | public class ScheduledExecutorSubclassTe
700          }};
701          for (int i = 0; i < count; i++)
702              p.execute(waiter);
703 <        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
703 >        await(threadsStarted);
704          assertEquals(poolSize, p.getActiveCount());
705          assertEquals(0, p.getCompletedTaskCount());
706          final List<Runnable> queuedTasks;
# Line 1220 | Line 1218 | public class ScheduledExecutorSubclassTe
1218       * timed invokeAll(c) cancels tasks not completed by timeout
1219       */
1220      public void testTimedInvokeAll6() throws Exception {
1221 <        final ExecutorService e = new CustomExecutor(2);
1222 <        try (PoolCleaner cleaner = cleaner(e)) {
1223 <            for (long timeout = timeoutMillis();;) {
1221 >        for (long timeout = timeoutMillis();;) {
1222 >            final CountDownLatch done = new CountDownLatch(1);
1223 >            final Callable<String> waiter = new CheckedCallable<String>() {
1224 >                public String realCall() {
1225 >                    try { done.await(LONG_DELAY_MS, MILLISECONDS); }
1226 >                    catch (InterruptedException ok) {}
1227 >                    return "1"; }};
1228 >            final ExecutorService p = new CustomExecutor(2);
1229 >            try (PoolCleaner cleaner = cleaner(p, done)) {
1230                  List<Callable<String>> tasks = new ArrayList<>();
1231                  tasks.add(new StringTask("0"));
1232 <                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1232 >                tasks.add(waiter);
1233                  tasks.add(new StringTask("2"));
1234                  long startTime = System.nanoTime();
1235                  List<Future<String>> futures =
1236 <                    e.invokeAll(tasks, timeout, MILLISECONDS);
1236 >                    p.invokeAll(tasks, timeout, MILLISECONDS);
1237                  assertEquals(tasks.size(), futures.size());
1238                  assertTrue(millisElapsedSince(startTime) >= timeout);
1239                  for (Future future : futures)

Diff Legend

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