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.71 by jsr166, Tue Oct 6 05:22:25 2015 UTC vs.
Revision 1.74 by jsr166, Tue Oct 6 16:39:06 2015 UTC

# Line 42 | Line 42 | public class ScheduledExecutorTest exten
42       * execute successfully executes a runnable
43       */
44      public void testExecute() throws InterruptedException {
45 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
45 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
46          try (PoolCleaner cleaner = cleaner(p)) {
47              final CountDownLatch done = new CountDownLatch(1);
48              final Runnable task = new CheckedRunnable() {
# Line 56 | Line 56 | public class ScheduledExecutorTest exten
56       * delayed schedule of callable successfully executes after delay
57       */
58      public void testSchedule1() throws Exception {
59 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
59 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
60          try (PoolCleaner cleaner = cleaner(p)) {
61              final long startTime = System.nanoTime();
62              final CountDownLatch done = new CountDownLatch(1);
# Line 77 | Line 77 | public class ScheduledExecutorTest exten
77       * delayed schedule of runnable successfully executes after delay
78       */
79      public void testSchedule3() throws Exception {
80 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
80 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
81          try (PoolCleaner cleaner = cleaner(p)) {
82              final long startTime = System.nanoTime();
83              final CountDownLatch done = new CountDownLatch(1);
# Line 97 | Line 97 | public class ScheduledExecutorTest exten
97       * scheduleAtFixedRate executes runnable after given initial delay
98       */
99      public void testSchedule4() throws Exception {
100 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
100 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
101          try (PoolCleaner cleaner = cleaner(p)) {
102              final long startTime = System.nanoTime();
103              final CountDownLatch done = new CountDownLatch(1);
# Line 119 | Line 119 | public class ScheduledExecutorTest exten
119       * scheduleWithFixedDelay executes runnable after given initial delay
120       */
121      public void testSchedule5() throws Exception {
122 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
122 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
123          try (PoolCleaner cleaner = cleaner(p)) {
124              final long startTime = System.nanoTime();
125              final CountDownLatch done = new CountDownLatch(1);
# Line 146 | Line 146 | public class ScheduledExecutorTest exten
146       * scheduleAtFixedRate executes series of tasks at given rate
147       */
148      public void testFixedRateSequence() throws InterruptedException {
149 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
149 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
150          try (PoolCleaner cleaner = cleaner(p)) {
151              for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
152                  long startTime = System.nanoTime();
# Line 172 | Line 172 | public class ScheduledExecutorTest exten
172       * scheduleWithFixedDelay executes series of tasks with given period
173       */
174      public void testFixedDelaySequence() throws InterruptedException {
175 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
175 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
176          try (PoolCleaner cleaner = cleaner(p)) {
177              for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
178                  long startTime = System.nanoTime();
# Line 198 | Line 198 | public class ScheduledExecutorTest exten
198       * execute(null) throws NPE
199       */
200      public void testExecuteNull() throws InterruptedException {
201 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
201 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
202          try (PoolCleaner cleaner = cleaner(p)) {
203              try {
204                  p.execute(null);
# Line 225 | Line 225 | public class ScheduledExecutorTest exten
225       * execute throws RejectedExecutionException if shutdown
226       */
227      public void testSchedule1_RejectedExecutionException() throws InterruptedException {
228 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
228 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
229          try (PoolCleaner cleaner = cleaner(p)) {
230              try {
231                  p.shutdown();
# Line 241 | Line 241 | public class ScheduledExecutorTest exten
241       * schedule throws RejectedExecutionException if shutdown
242       */
243      public void testSchedule2_RejectedExecutionException() throws InterruptedException {
244 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
244 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
245          try (PoolCleaner cleaner = cleaner(p)) {
246              try {
247                  p.shutdown();
# Line 257 | Line 257 | public class ScheduledExecutorTest exten
257       * schedule callable throws RejectedExecutionException if shutdown
258       */
259      public void testSchedule3_RejectedExecutionException() throws InterruptedException {
260 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
260 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
261          try (PoolCleaner cleaner = cleaner(p)) {
262              try {
263                  p.shutdown();
# Line 273 | Line 273 | public class ScheduledExecutorTest exten
273       * scheduleAtFixedRate throws RejectedExecutionException if shutdown
274       */
275      public void testScheduleAtFixedRate1_RejectedExecutionException() throws InterruptedException {
276 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
276 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
277          try (PoolCleaner cleaner = cleaner(p)) {
278              try {
279                  p.shutdown();
# Line 289 | Line 289 | public class ScheduledExecutorTest exten
289       * scheduleWithFixedDelay throws RejectedExecutionException if shutdown
290       */
291      public void testScheduleWithFixedDelay1_RejectedExecutionException() throws InterruptedException {
292 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
292 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
293          try (PoolCleaner cleaner = cleaner(p)) {
294              try {
295                  p.shutdown();
# Line 306 | Line 306 | public class ScheduledExecutorTest exten
306       * thread becomes active
307       */
308      public void testGetActiveCount() throws InterruptedException {
309 +        final CountDownLatch done = new CountDownLatch(1);
310          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(2);
311 <        try (PoolCleaner cleaner = cleaner(p)) {
311 >        try (PoolCleaner cleaner = cleaner(p, done)) {
312              final CountDownLatch threadStarted = new CountDownLatch(1);
312 –            final CountDownLatch done = new CountDownLatch(1);
313              assertEquals(0, p.getActiveCount());
314              p.execute(new CheckedRunnable() {
315                  public void realRun() throws InterruptedException {
# Line 317 | Line 317 | public class ScheduledExecutorTest exten
317                      assertEquals(1, p.getActiveCount());
318                      await(done);
319                  }});
320 <            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
320 >            await(threadStarted);
321              assertEquals(1, p.getActiveCount());
322 –            done.countDown();
322          }
323      }
324  
# Line 426 | Line 425 | public class ScheduledExecutorTest exten
425                      threadStarted.countDown();
426                      await(done);
427                  }});
428 <            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
428 >            await(threadStarted);
429              assertEquals(1, p.getTaskCount());
430              assertEquals(0, p.getCompletedTaskCount());
431              for (int i = 0; i < TASKS; i++) {
# Line 462 | Line 461 | public class ScheduledExecutorTest exten
461       */
462      public void testSetThreadFactory() throws InterruptedException {
463          ThreadFactory threadFactory = new SimpleThreadFactory();
464 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
464 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
465          try (PoolCleaner cleaner = cleaner(p)) {
466              p.setThreadFactory(threadFactory);
467              assertSame(threadFactory, p.getThreadFactory());
# Line 473 | Line 472 | public class ScheduledExecutorTest exten
472       * setThreadFactory(null) throws NPE
473       */
474      public void testSetThreadFactoryNull() throws InterruptedException {
475 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
475 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
476          try (PoolCleaner cleaner = cleaner(p)) {
477              try {
478                  p.setThreadFactory(null);
# Line 487 | Line 486 | public class ScheduledExecutorTest exten
486       */
487      public void testIsShutdown() {
488  
489 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
489 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
490          try {
491              assertFalse(p.isShutdown());
492          }
# Line 512 | Line 511 | public class ScheduledExecutorTest exten
511                      threadStarted.countDown();
512                      await(done);
513                  }});
514 <            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
514 >            await(threadStarted);
515              assertFalse(p.isTerminating());
516              done.countDown();
517              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 536 | Line 535 | public class ScheduledExecutorTest exten
535                      threadStarted.countDown();
536                      await(done);
537                  }});
538 <            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
538 >            await(threadStarted);
539              assertFalse(p.isTerminating());
540              done.countDown();
541              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 550 | Line 549 | public class ScheduledExecutorTest exten
549       * getQueue returns the work queue, which contains queued tasks
550       */
551      public void testGetQueue() throws InterruptedException {
552 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
553 <        try (PoolCleaner cleaner = cleaner(p)) {
552 >        final CountDownLatch done = new CountDownLatch(1);
553 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
554 >        try (PoolCleaner cleaner = cleaner(p, done)) {
555              final CountDownLatch threadStarted = new CountDownLatch(1);
556 –            final CountDownLatch done = new CountDownLatch(1);
556              ScheduledFuture[] tasks = new ScheduledFuture[5];
557              for (int i = 0; i < tasks.length; i++) {
558                  Runnable r = new CheckedRunnable() {
# Line 563 | Line 562 | public class ScheduledExecutorTest exten
562                      }};
563                  tasks[i] = p.schedule(r, 1, MILLISECONDS);
564              }
565 <            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
565 >            await(threadStarted);
566              BlockingQueue<Runnable> q = p.getQueue();
567              assertTrue(q.contains(tasks[tasks.length - 1]));
568              assertFalse(q.contains(tasks[0]));
570 –            done.countDown();
569          }
570      }
571  
# Line 575 | Line 573 | public class ScheduledExecutorTest exten
573       * remove(task) removes queued task, and fails to remove active task
574       */
575      public void testRemove() throws InterruptedException {
576 +        final CountDownLatch done = new CountDownLatch(1);
577          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
578 <        try (PoolCleaner cleaner = cleaner(p)) {
578 >        try (PoolCleaner cleaner = cleaner(p, done)) {
579              ScheduledFuture[] tasks = new ScheduledFuture[5];
580              final CountDownLatch threadStarted = new CountDownLatch(1);
582 –            final CountDownLatch done = new CountDownLatch(1);
581              for (int i = 0; i < tasks.length; i++) {
582                  Runnable r = new CheckedRunnable() {
583                      public void realRun() throws InterruptedException {
# Line 588 | Line 586 | public class ScheduledExecutorTest exten
586                      }};
587                  tasks[i] = p.schedule(r, 1, MILLISECONDS);
588              }
589 <            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
589 >            await(threadStarted);
590              BlockingQueue<Runnable> q = p.getQueue();
591              assertFalse(p.remove((Runnable)tasks[0]));
592              assertTrue(q.contains((Runnable)tasks[4]));
# Line 599 | Line 597 | public class ScheduledExecutorTest exten
597              assertTrue(q.contains((Runnable)tasks[3]));
598              assertTrue(p.remove((Runnable)tasks[3]));
599              assertFalse(q.contains((Runnable)tasks[3]));
602 –            done.countDown();
600          }
601      }
602  
# Line 675 | Line 672 | public class ScheduledExecutorTest exten
672       * and those tasks are drained from the queue
673       */
674      public void testShutdownNow_delayedTasks() throws InterruptedException {
675 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
675 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
676          List<ScheduledFuture> tasks = new ArrayList<>();
677          for (int i = 0; i < 3; i++) {
678              Runnable r = new NoOpRunnable();
# Line 1171 | Line 1168 | public class ScheduledExecutorTest exten
1168       * timed invokeAll(c) cancels tasks not completed by timeout
1169       */
1170      public void testTimedInvokeAll6() throws Exception {
1171 <        final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1172 <        try (PoolCleaner cleaner = cleaner(e)) {
1173 <            for (long timeout = timeoutMillis();;) {
1171 >        for (long timeout = timeoutMillis();;) {
1172 >            final CountDownLatch done = new CountDownLatch(1);
1173 >            final Callable<String> waiter = new CheckedCallable<String>() {
1174 >                public String realCall() {
1175 >                    try { done.await(LONG_DELAY_MS, MILLISECONDS); }
1176 >                    catch (InterruptedException ok) {}
1177 >                    return "1"; }};
1178 >            final ExecutorService p = new ScheduledThreadPoolExecutor(2);
1179 >            try (PoolCleaner cleaner = cleaner(p, done)) {
1180                  List<Callable<String>> tasks = new ArrayList<>();
1181                  tasks.add(new StringTask("0"));
1182 <                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1182 >                tasks.add(waiter);
1183                  tasks.add(new StringTask("2"));
1184                  long startTime = System.nanoTime();
1185                  List<Future<String>> futures =
1186 <                    e.invokeAll(tasks, timeout, MILLISECONDS);
1186 >                    p.invokeAll(tasks, timeout, MILLISECONDS);
1187                  assertEquals(tasks.size(), futures.size());
1188                  assertTrue(millisElapsedSince(startTime) >= timeout);
1189                  for (Future future : futures)

Diff Legend

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