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

Comparing jsr166/src/test/tck/ScheduledExecutorTest.java (file contents):
Revision 1.94 by jsr166, Mon May 29 22:44:27 2017 UTC vs.
Revision 1.100 by jsr166, Wed Jan 27 01:57:24 2021 UTC

# Line 66 | Line 66 | public class ScheduledExecutorTest exten
66          try (PoolCleaner cleaner = cleaner(p)) {
67              final long startTime = System.nanoTime();
68              final CountDownLatch done = new CountDownLatch(1);
69 <            Callable task = new CheckedCallable<Boolean>() {
69 >            Callable<Boolean> task = new CheckedCallable<>() {
70                  public Boolean realCall() {
71                      done.countDown();
72                      assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
73                      return Boolean.TRUE;
74                  }};
75 <            Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
75 >            Future<Boolean> f = p.schedule(task, timeoutMillis(), MILLISECONDS);
76              assertSame(Boolean.TRUE, f.get());
77              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
78              assertEquals(0L, done.getCount());
# Line 92 | Line 92 | public class ScheduledExecutorTest exten
92                      done.countDown();
93                      assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
94                  }};
95 <            Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
95 >            Future<?> f = p.schedule(task, timeoutMillis(), MILLISECONDS);
96              await(done);
97              assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
98              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
# Line 112 | Line 112 | public class ScheduledExecutorTest exten
112                      done.countDown();
113                      assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
114                  }};
115 <            ScheduledFuture f =
115 >            ScheduledFuture<?> f =
116                  p.scheduleAtFixedRate(task, timeoutMillis(),
117                                        LONG_DELAY_MS, MILLISECONDS);
118              await(done);
# Line 134 | Line 134 | public class ScheduledExecutorTest exten
134                      done.countDown();
135                      assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
136                  }};
137 <            ScheduledFuture f =
137 >            ScheduledFuture<?> f =
138                  p.scheduleWithFixedDelay(task, timeoutMillis(),
139                                           LONG_DELAY_MS, MILLISECONDS);
140              await(done);
# Line 162 | Line 162 | public class ScheduledExecutorTest exten
162                  final CountDownLatch done = new CountDownLatch(cycles);
163                  final Runnable task = new CheckedRunnable() {
164                      public void realRun() { done.countDown(); }};
165 <                final ScheduledFuture periodicTask =
165 >                final ScheduledFuture<?> periodicTask =
166                      p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);
167                  final int totalDelayMillis = (cycles - 1) * delay;
168                  await(done, totalDelayMillis + LONG_DELAY_MS);
# Line 208 | Line 208 | public class ScheduledExecutorTest exten
208                          previous.set(now);
209                          done.countDown();
210                      }};
211 <                final ScheduledFuture periodicTask =
211 >                final ScheduledFuture<?> periodicTask =
212                      p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS);
213                  final int totalDelayMillis = (cycles - 1) * delay;
214                  await(done, totalDelayMillis + cycles * LONG_DELAY_MS);
# Line 224 | Line 224 | public class ScheduledExecutorTest exten
224      }
225  
226      /**
227 <     * execute(null) throws NPE
227 >     * Submitting null tasks throws NullPointerException
228       */
229 <    public void testExecuteNull() throws InterruptedException {
229 >    public void testNullTaskSubmission() {
230          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
231          try (PoolCleaner cleaner = cleaner(p)) {
232 <            try {
233 <                p.execute(null);
234 <                shouldThrow();
235 <            } catch (NullPointerException success) {}
232 >            assertNullTaskSubmissionThrowsNullPointerException(p);
233          }
234      }
235  
236      /**
237 <     * schedule(null) throws NPE
237 >     * Submitted tasks are rejected when shutdown
238       */
239 <    public void testScheduleNull() throws InterruptedException {
239 >    public void testSubmittedTasksRejectedWhenShutdown() throws InterruptedException {
240          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
241 <        try (PoolCleaner cleaner = cleaner(p)) {
242 <            try {
243 <                Future f = p.schedule((Callable)null,
244 <                                      randomTimeout(), randomTimeUnit());
245 <                shouldThrow();
246 <            } catch (NullPointerException success) {}
247 <        }
248 <    }
241 >        final ThreadLocalRandom rnd = ThreadLocalRandom.current();
242 >        final CountDownLatch threadsStarted = new CountDownLatch(p.getCorePoolSize());
243 >        final CountDownLatch done = new CountDownLatch(1);
244 >        final Runnable r = () -> {
245 >            threadsStarted.countDown();
246 >            for (;;) {
247 >                try {
248 >                    done.await();
249 >                    return;
250 >                } catch (InterruptedException shutdownNowDeliberatelyIgnored) {}
251 >            }};
252 >        final Callable<Boolean> c = () -> {
253 >            threadsStarted.countDown();
254 >            for (;;) {
255 >                try {
256 >                    done.await();
257 >                    return Boolean.TRUE;
258 >                } catch (InterruptedException shutdownNowDeliberatelyIgnored) {}
259 >            }};
260  
261 <    /**
262 <     * execute throws RejectedExecutionException if shutdown
263 <     */
264 <    public void testSchedule1_RejectedExecutionException() throws InterruptedException {
265 <        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
266 <        try (PoolCleaner cleaner = cleaner(p)) {
267 <            try {
268 <                p.shutdown();
269 <                p.schedule(new NoOpRunnable(),
262 <                           randomTimeout(), randomTimeUnit());
263 <                shouldThrow();
264 <            } catch (RejectedExecutionException success) {
265 <            } catch (SecurityException ok) {}
266 <        }
267 <    }
261 >        try (PoolCleaner cleaner = cleaner(p, done)) {
262 >            for (int i = p.getCorePoolSize(); i--> 0; ) {
263 >                switch (rnd.nextInt(4)) {
264 >                case 0: p.execute(r); break;
265 >                case 1: assertFalse(p.submit(r).isDone()); break;
266 >                case 2: assertFalse(p.submit(r, Boolean.TRUE).isDone()); break;
267 >                case 3: assertFalse(p.submit(c).isDone()); break;
268 >                }
269 >            }
270  
271 <    /**
272 <     * schedule throws RejectedExecutionException if shutdown
271 <     */
272 <    public void testSchedule2_RejectedExecutionException() throws InterruptedException {
273 <        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
274 <        try (PoolCleaner cleaner = cleaner(p)) {
275 <            try {
276 <                p.shutdown();
277 <                p.schedule(new NoOpCallable(),
278 <                           randomTimeout(), randomTimeUnit());
279 <                shouldThrow();
280 <            } catch (RejectedExecutionException success) {
281 <            } catch (SecurityException ok) {}
282 <        }
283 <    }
271 >            // ScheduledThreadPoolExecutor has an unbounded queue, so never saturated.
272 >            await(threadsStarted);
273  
274 <    /**
275 <     * schedule callable throws RejectedExecutionException if shutdown
276 <     */
288 <    public void testSchedule3_RejectedExecutionException() throws InterruptedException {
289 <        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
290 <        try (PoolCleaner cleaner = cleaner(p)) {
291 <            try {
274 >            if (rnd.nextBoolean())
275 >                p.shutdownNow();
276 >            else
277                  p.shutdown();
278 <                p.schedule(new NoOpCallable(),
279 <                           randomTimeout(), randomTimeUnit());
280 <                shouldThrow();
296 <            } catch (RejectedExecutionException success) {
297 <            } catch (SecurityException ok) {}
298 <        }
299 <    }
278 >            // Pool is shutdown, but not yet terminated
279 >            assertTaskSubmissionsAreRejected(p);
280 >            assertFalse(p.isTerminated());
281  
282 <    /**
283 <     * scheduleAtFixedRate throws RejectedExecutionException if shutdown
303 <     */
304 <    public void testScheduleAtFixedRate1_RejectedExecutionException() throws InterruptedException {
305 <        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
306 <        try (PoolCleaner cleaner = cleaner(p)) {
307 <            try {
308 <                p.shutdown();
309 <                p.scheduleAtFixedRate(new NoOpRunnable(),
310 <                                      MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS);
311 <                shouldThrow();
312 <            } catch (RejectedExecutionException success) {
313 <            } catch (SecurityException ok) {}
314 <        }
315 <    }
282 >            done.countDown();   // release blocking tasks
283 >            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
284  
285 <    /**
318 <     * scheduleWithFixedDelay throws RejectedExecutionException if shutdown
319 <     */
320 <    public void testScheduleWithFixedDelay1_RejectedExecutionException() throws InterruptedException {
321 <        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
322 <        try (PoolCleaner cleaner = cleaner(p)) {
323 <            try {
324 <                p.shutdown();
325 <                p.scheduleWithFixedDelay(new NoOpRunnable(),
326 <                                         MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS);
327 <                shouldThrow();
328 <            } catch (RejectedExecutionException success) {
329 <            } catch (SecurityException ok) {}
285 >            assertTaskSubmissionsAreRejected(p);
286          }
287 +        assertEquals(p.getCorePoolSize(), p.getCompletedTaskCount());
288      }
289  
290      /**
# Line 592 | Line 549 | public class ScheduledExecutorTest exten
549          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
550          try (PoolCleaner cleaner = cleaner(p, done)) {
551              final CountDownLatch threadStarted = new CountDownLatch(1);
552 <            ScheduledFuture[] tasks = new ScheduledFuture[5];
552 >            @SuppressWarnings("unchecked")
553 >            ScheduledFuture<?>[] tasks = (ScheduledFuture<?>[])new ScheduledFuture[5];
554              for (int i = 0; i < tasks.length; i++) {
555                  Runnable r = new CheckedRunnable() {
556                      public void realRun() throws InterruptedException {
# Line 615 | Line 573 | public class ScheduledExecutorTest exten
573          final CountDownLatch done = new CountDownLatch(1);
574          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
575          try (PoolCleaner cleaner = cleaner(p, done)) {
576 <            ScheduledFuture[] tasks = new ScheduledFuture[5];
576 >            @SuppressWarnings("unchecked")
577 >            ScheduledFuture<?>[] tasks = (ScheduledFuture<?>[])new ScheduledFuture[5];
578              final CountDownLatch threadStarted = new CountDownLatch(1);
579              for (int i = 0; i < tasks.length; i++) {
580                  Runnable r = new CheckedRunnable() {
# Line 643 | Line 602 | public class ScheduledExecutorTest exten
602       * purge eventually removes cancelled tasks from the queue
603       */
604      public void testPurge() throws InterruptedException {
605 <        final ScheduledFuture[] tasks = new ScheduledFuture[5];
605 >        @SuppressWarnings("unchecked")
606 >        ScheduledFuture<?>[] tasks = (ScheduledFuture<?>[])new ScheduledFuture[5];
607          final Runnable releaser = new Runnable() { public void run() {
608 <            for (ScheduledFuture task : tasks)
608 >            for (ScheduledFuture<?> task : tasks)
609                  if (task != null) task.cancel(true); }};
610          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
611          try (PoolCleaner cleaner = cleaner(p, releaser)) {
612              for (int i = 0; i < tasks.length; i++)
613 <                tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
613 >                tasks[i] = p.schedule(possiblyInterruptedRunnable(SMALL_DELAY_MS),
614                                        LONG_DELAY_MS, MILLISECONDS);
615              int max = tasks.length;
616              if (tasks[4].cancel(true)) --max;
# Line 682 | Line 642 | public class ScheduledExecutorTest exten
642          Runnable waiter = new CheckedRunnable() { public void realRun() {
643              threadsStarted.countDown();
644              try {
645 <                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
645 >                MILLISECONDS.sleep(LONGER_DELAY_MS);
646              } catch (InterruptedException success) {}
647              ran.getAndIncrement();
648          }};
# Line 712 | Line 672 | public class ScheduledExecutorTest exten
672       */
673      public void testShutdownNow_delayedTasks() throws InterruptedException {
674          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
675 <        List<ScheduledFuture> tasks = new ArrayList<>();
675 >        List<ScheduledFuture<?>> tasks = new ArrayList<>();
676          for (int i = 0; i < 3; i++) {
677              Runnable r = new NoOpRunnable();
678              tasks.add(p.schedule(r, 9, SECONDS));
# Line 720 | Line 680 | public class ScheduledExecutorTest exten
680              tasks.add(p.scheduleWithFixedDelay(r, 9, 9, SECONDS));
681          }
682          if (testImplementationDetails)
683 <            assertEquals(new HashSet(tasks), new HashSet(p.getQueue()));
683 >            assertEquals(new HashSet<Object>(tasks), new HashSet<Object>(p.getQueue()));
684          final List<Runnable> queuedTasks;
685          try {
686              queuedTasks = p.shutdownNow();
# Line 730 | Line 690 | public class ScheduledExecutorTest exten
690          assertTrue(p.isShutdown());
691          assertTrue(p.getQueue().isEmpty());
692          if (testImplementationDetails)
693 <            assertEquals(new HashSet(tasks), new HashSet(queuedTasks));
693 >            assertEquals(new HashSet<Object>(tasks), new HashSet<Object>(queuedTasks));
694          assertEquals(tasks.size(), queuedTasks.size());
695 <        for (ScheduledFuture task : tasks) {
695 >        for (ScheduledFuture<?> task : tasks) {
696              assertFalse(task.isDone());
697              assertFalse(task.isCancelled());
698          }
# Line 747 | Line 707 | public class ScheduledExecutorTest exten
707       * - setExecuteExistingDelayedTasksAfterShutdownPolicy
708       * - setContinueExistingPeriodicTasksAfterShutdownPolicy
709       */
710 +    @SuppressWarnings("FutureReturnValueIgnored")
711      public void testShutdown_cancellation() throws Exception {
712          final int poolSize = 4;
713          final ScheduledThreadPoolExecutor p
# Line 846 | Line 807 | public class ScheduledExecutorTest exten
807          immediates.forEach(
808              f -> assertTrue(((ScheduledFuture)f).getDelay(NANOSECONDS) <= 0L));
809  
810 <        Stream.of(immediates, delayeds, periodics).flatMap(c -> c.stream())
810 >        Stream.of(immediates, delayeds, periodics).flatMap(Collection::stream)
811              .forEach(f -> assertFalse(f.isDone()));
812  
813          try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 900 | Line 861 | public class ScheduledExecutorTest exten
861  
862          assertTrue(q.isEmpty());
863  
864 <        Stream.of(immediates, delayeds, periodics).flatMap(c -> c.stream())
864 >        Stream.of(immediates, delayeds, periodics).flatMap(Collection::stream)
865              .forEach(f -> assertTrue(f.isDone()));
866  
867          for (Future<?> f : immediates) assertNull(f.get());
# Line 1314 | Line 1275 | public class ScheduledExecutorTest exten
1275      public void testTimedInvokeAll6() throws Exception {
1276          for (long timeout = timeoutMillis();;) {
1277              final CountDownLatch done = new CountDownLatch(1);
1278 <            final Callable<String> waiter = new CheckedCallable<String>() {
1278 >            final Callable<String> waiter = new CheckedCallable<>() {
1279                  public String realCall() {
1280                      try { done.await(LONG_DELAY_MS, MILLISECONDS); }
1281                      catch (InterruptedException ok) {}
# Line 1330 | Line 1291 | public class ScheduledExecutorTest exten
1291                      p.invokeAll(tasks, timeout, MILLISECONDS);
1292                  assertEquals(tasks.size(), futures.size());
1293                  assertTrue(millisElapsedSince(startTime) >= timeout);
1294 <                for (Future future : futures)
1294 >                for (Future<?> future : futures)
1295                      assertTrue(future.isDone());
1296                  assertTrue(futures.get(1).isCancelled());
1297                  try {
# Line 1351 | Line 1312 | public class ScheduledExecutorTest exten
1312       * one-shot task from executing.
1313       * https://bugs.openjdk.java.net/browse/JDK-8051859
1314       */
1315 +    @SuppressWarnings("FutureReturnValueIgnored")
1316      public void testScheduleWithFixedDelay_overflow() throws Exception {
1317          final CountDownLatch delayedDone = new CountDownLatch(1);
1318          final CountDownLatch immediateDone = new CountDownLatch(1);
1319          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
1320          try (PoolCleaner cleaner = cleaner(p)) {
1321 <            final Runnable immediate = new Runnable() { public void run() {
1360 <                immediateDone.countDown();
1361 <            }};
1362 <            final Runnable delayed = new Runnable() { public void run() {
1321 >            final Runnable delayed = () -> {
1322                  delayedDone.countDown();
1323 <                p.submit(immediate);
1324 <            }};
1323 >                p.submit(() -> immediateDone.countDown());
1324 >            };
1325              p.scheduleWithFixedDelay(delayed, 0L, Long.MAX_VALUE, SECONDS);
1326              await(delayedDone);
1327              await(immediateDone);

Diff Legend

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