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.8 by dl, Sun Oct 5 23:00:40 2003 UTC vs.
Revision 1.9 by dl, Thu Dec 4 20:54:46 2003 UTC

# Line 24 | Line 24 | public class ScheduledExecutorTest exten
24      public void testExecute() {
25          try {
26              TrackedShortRunnable runnable =new TrackedShortRunnable();
27 <            ScheduledExecutor p1 = new ScheduledExecutor(1);
27 >            ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
28              p1.execute(runnable);
29              assertFalse(runnable.done);
30              Thread.sleep(SHORT_DELAY_MS);
# Line 51 | Line 51 | public class ScheduledExecutorTest exten
51      public void testSchedule1() {
52          try {
53              TrackedCallable callable = new TrackedCallable();
54 <            ScheduledExecutor p1 = new ScheduledExecutor(1);
54 >            ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
55              Future f = p1.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
56              assertFalse(callable.done);
57              Thread.sleep(MEDIUM_DELAY_MS);
# Line 61 | Line 61 | public class ScheduledExecutorTest exten
61              joinPool(p1);
62          } catch(RejectedExecutionException e){}
63          catch(Exception e){
64 +            e.printStackTrace();
65              unexpectedException();
66          }
67      }
# Line 71 | Line 72 | public class ScheduledExecutorTest exten
72      public void testSchedule3() {
73          try {
74              TrackedShortRunnable runnable = new TrackedShortRunnable();
75 <            ScheduledExecutor p1 = new ScheduledExecutor(1);
75 >            ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
76              p1.schedule(runnable, SMALL_DELAY_MS, TimeUnit.MILLISECONDS);
77              Thread.sleep(SHORT_DELAY_MS);
78              assertFalse(runnable.done);
# Line 90 | Line 91 | public class ScheduledExecutorTest exten
91      public void testSchedule4() {
92          try {
93              TrackedShortRunnable runnable = new TrackedShortRunnable();
94 <            ScheduledExecutor p1 = new ScheduledExecutor(1);
95 <            ScheduledCancellable h = p1.scheduleAtFixedRate(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
94 >            ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
95 >            ScheduledFuture h = p1.scheduleAtFixedRate(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
96              assertFalse(runnable.done);
97              Thread.sleep(MEDIUM_DELAY_MS);
98              assertTrue(runnable.done);
# Line 109 | Line 110 | public class ScheduledExecutorTest exten
110      public void testSchedule5() {
111          try {
112              TrackedShortRunnable runnable = new TrackedShortRunnable();
113 <            ScheduledExecutor p1 = new ScheduledExecutor(1);
114 <            ScheduledCancellable h = p1.scheduleWithFixedDelay(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
113 >            ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
114 >            ScheduledFuture h = p1.scheduleWithFixedDelay(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
115              assertFalse(runnable.done);
116              Thread.sleep(MEDIUM_DELAY_MS);
117              assertTrue(runnable.done);
# Line 126 | Line 127 | public class ScheduledExecutorTest exten
127       *  execute (null) throws NPE
128       */
129      public void testExecuteNull() {
130 <        ScheduledExecutor se = null;
130 >        ScheduledThreadPoolExecutor se = null;
131          try {
132 <            se = new ScheduledExecutor(1);
132 >            se = new ScheduledThreadPoolExecutor(1);
133              se.execute(null);
134              shouldThrow();
135          } catch(NullPointerException success){}
# Line 143 | Line 144 | public class ScheduledExecutorTest exten
144       * schedule (null) throws NPE
145       */
146      public void testScheduleNull() {
147 <        ScheduledExecutor se = new ScheduledExecutor(1);
147 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
148          try {
149              TrackedCallable callable = null;
150              Future f = se.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
# Line 159 | Line 160 | public class ScheduledExecutorTest exten
160       * execute throws RejectedExecutionException if shutdown
161       */
162      public void testSchedule1_RejectedExecutionException() {
163 <        ScheduledExecutor se = new ScheduledExecutor(1);
163 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
164          try {
165              se.shutdown();
166              se.schedule(new NoOpRunnable(),
# Line 175 | Line 176 | public class ScheduledExecutorTest exten
176       * schedule throws RejectedExecutionException if shutdown
177       */
178      public void testSchedule2_RejectedExecutionException() {
179 <        ScheduledExecutor se = new ScheduledExecutor(1);
179 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
180          try {
181              se.shutdown();
182              se.schedule(new NoOpCallable(),
# Line 190 | Line 191 | public class ScheduledExecutorTest exten
191       * schedule callable throws RejectedExecutionException if shutdown
192       */
193       public void testSchedule3_RejectedExecutionException() {
194 <         ScheduledExecutor se = new ScheduledExecutor(1);
194 >         ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
195           try {
196              se.shutdown();
197              se.schedule(new NoOpCallable(),
# Line 205 | Line 206 | public class ScheduledExecutorTest exten
206       *  scheduleAtFixedRate throws RejectedExecutionException if shutdown
207       */
208      public void testScheduleAtFixedRate1_RejectedExecutionException() {
209 <        ScheduledExecutor se = new ScheduledExecutor(1);
209 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
210          try {
211              se.shutdown();
212              se.scheduleAtFixedRate(new NoOpRunnable(),
# Line 220 | Line 221 | public class ScheduledExecutorTest exten
221       * scheduleWithFixedDelay throws RejectedExecutionException if shutdown
222       */
223      public void testScheduleWithFixedDelay1_RejectedExecutionException() {
224 <        ScheduledExecutor se = new ScheduledExecutor(1);
224 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
225          try {
226              se.shutdown();
227              se.scheduleWithFixedDelay(new NoOpRunnable(),
# Line 236 | Line 237 | public class ScheduledExecutorTest exten
237       *  thread becomes active
238       */
239      public void testGetActiveCount() {
240 <        ScheduledExecutor p2 = new ScheduledExecutor(2);
240 >        ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2);
241          assertEquals(0, p2.getActiveCount());
242          p2.execute(new SmallRunnable());
243          try {
# Line 253 | Line 254 | public class ScheduledExecutorTest exten
254       *   when tasks complete
255       */
256      public void testGetCompletedTaskCount() {
257 <        ScheduledExecutor p2 = new ScheduledExecutor(2);
257 >        ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2);
258          assertEquals(0, p2.getCompletedTaskCount());
259          p2.execute(new SmallRunnable());
260          try {
# Line 269 | Line 270 | public class ScheduledExecutorTest exten
270       *  getCorePoolSize returns size given in constructor if not otherwise set
271       */
272      public void testGetCorePoolSize() {
273 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
273 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
274          assertEquals(1, p1.getCorePoolSize());
275          joinPool(p1);
276      }
# Line 279 | Line 280 | public class ScheduledExecutorTest exten
280       *   multiple threads active
281       */
282      public void testGetLargestPoolSize() {
283 <        ScheduledExecutor p2 = new ScheduledExecutor(2);
283 >        ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2);
284          assertEquals(0, p2.getLargestPoolSize());
285          p2.execute(new SmallRunnable());
286          p2.execute(new SmallRunnable());
# Line 297 | Line 298 | public class ScheduledExecutorTest exten
298       *   become active
299       */
300      public void testGetPoolSize() {
301 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
301 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
302          assertEquals(0, p1.getPoolSize());
303          p1.execute(new SmallRunnable());
304          assertEquals(1, p1.getPoolSize());
# Line 309 | Line 310 | public class ScheduledExecutorTest exten
310       *    submitted
311       */
312      public void testGetTaskCount() {
313 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
313 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
314          assertEquals(0, p1.getTaskCount());
315          for(int i = 0; i < 5; i++)
316              p1.execute(new SmallRunnable());
# Line 327 | Line 328 | public class ScheduledExecutorTest exten
328       */
329      public void testGetThreadFactory() {
330          ThreadFactory tf = new SimpleThreadFactory();
331 <        ScheduledExecutor p = new ScheduledExecutor(1, tf);
331 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1, tf);
332          assertSame(tf, p.getThreadFactory());
333          p.shutdown();
334          joinPool(p);
# Line 338 | Line 339 | public class ScheduledExecutorTest exten
339       */
340      public void testSetThreadFactory() {
341          ThreadFactory tf = new SimpleThreadFactory();
342 <        ScheduledExecutor p = new ScheduledExecutor(1);
342 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
343          p.setThreadFactory(tf);
344          assertSame(tf, p.getThreadFactory());
345          p.shutdown();
# Line 349 | Line 350 | public class ScheduledExecutorTest exten
350       * setThreadFactory(null) throws NPE
351       */
352      public void testSetThreadFactoryNull() {
353 <        ScheduledExecutor p = new ScheduledExecutor(1);
353 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
354          try {
355              p.setThreadFactory(null);
356              shouldThrow();
# Line 364 | Line 365 | public class ScheduledExecutorTest exten
365       */
366      public void testIsShutdown() {
367          
368 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
368 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
369          try {
370              assertFalse(p1.isShutdown());
371          }
# Line 379 | Line 380 | public class ScheduledExecutorTest exten
380       *   isTerminated is false before termination, true after
381       */
382      public void testIsTerminated() {
383 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
383 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
384          try {
385              p1.execute(new SmallRunnable());
386          } finally {
# Line 397 | Line 398 | public class ScheduledExecutorTest exten
398       *  isTerminating is not true when running or when terminated
399       */
400      public void testIsTerminating() {
401 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
401 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
402          assertFalse(p1.isTerminating());
403          try {
404              p1.execute(new SmallRunnable());
# Line 418 | Line 419 | public class ScheduledExecutorTest exten
419       * getQueue returns the work queue, which contains queued tasks
420       */
421      public void testGetQueue() {
422 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
423 <        ScheduledCancellable[] tasks = new ScheduledCancellable[5];
422 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
423 >        ScheduledFuture[] tasks = new ScheduledFuture[5];
424          for(int i = 0; i < 5; i++){
425              tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, TimeUnit.MILLISECONDS);
426          }
# Line 440 | Line 441 | public class ScheduledExecutorTest exten
441       * remove(task) removes queued task, and fails to remove active task
442       */
443      public void testRemove() {
444 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
445 <        ScheduledCancellable[] tasks = new ScheduledCancellable[5];
444 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
445 >        ScheduledFuture[] tasks = new ScheduledFuture[5];
446          for(int i = 0; i < 5; i++){
447              tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, TimeUnit.MILLISECONDS);
448          }
# Line 469 | Line 470 | public class ScheduledExecutorTest exten
470       *  purge removes cancelled tasks from the queue
471       */
472      public void testPurge() {
473 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
474 <        ScheduledCancellable[] tasks = new ScheduledCancellable[5];
473 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
474 >        ScheduledFuture[] tasks = new ScheduledFuture[5];
475          for(int i = 0; i < 5; i++){
476              tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, TimeUnit.MILLISECONDS);
477          }
# Line 487 | Line 488 | public class ScheduledExecutorTest exten
488       *  shutDownNow returns a list containing tasks that were not run
489       */
490      public void testShutDownNow() {
491 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
491 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
492          for(int i = 0; i < 5; i++)
493              p1.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
494          List l = p1.shutdownNow();
# Line 502 | Line 503 | public class ScheduledExecutorTest exten
503       */
504      public void testShutDown1() {
505          try {
506 <            ScheduledExecutor p1 = new ScheduledExecutor(1);
506 >            ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
507              assertTrue(p1.getExecuteExistingDelayedTasksAfterShutdownPolicy());
508              assertFalse(p1.getContinueExistingPeriodicTasksAfterShutdownPolicy());
509  
510 <            ScheduledCancellable[] tasks = new ScheduledCancellable[5];
510 >            ScheduledFuture[] tasks = new ScheduledFuture[5];
511              for(int i = 0; i < 5; i++)
512                  tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
513              p1.shutdown();
514              BlockingQueue q = p1.getQueue();
515              for (Iterator it = q.iterator(); it.hasNext();) {
516 <                ScheduledCancellable t = (ScheduledCancellable)it.next();
516 >                ScheduledFuture t = (ScheduledFuture)it.next();
517                  assertFalse(t.isCancelled());
518              }
519              assertTrue(p1.isShutdown());
# Line 535 | Line 536 | public class ScheduledExecutorTest exten
536       */
537      public void testShutDown2() {
538          try {
539 <            ScheduledExecutor p1 = new ScheduledExecutor(1);
539 >            ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
540              p1.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
541 <            ScheduledCancellable[] tasks = new ScheduledCancellable[5];
541 >            ScheduledFuture[] tasks = new ScheduledFuture[5];
542              for(int i = 0; i < 5; i++)
543                  tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
544              p1.shutdown();
# Line 559 | Line 560 | public class ScheduledExecutorTest exten
560       */
561      public void testShutDown3() {
562          try {
563 <            ScheduledExecutor p1 = new ScheduledExecutor(1);
563 >            ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
564              p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
565 <            ScheduledCancellable task =
565 >            ScheduledFuture task =
566                  p1.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, TimeUnit.MILLISECONDS);
567              p1.shutdown();
568              assertTrue(p1.isShutdown());
# Line 580 | Line 581 | public class ScheduledExecutorTest exten
581       * periodic tasks are cancelled at shutdown
582       */
583      public void testShutDown4() {
584 <        ScheduledExecutor p1 = new ScheduledExecutor(1);
584 >        ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
585          try {
586              p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(true);
587 <            ScheduledCancellable task =
587 >            ScheduledFuture task =
588                  p1.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, TimeUnit.MILLISECONDS);
589              assertFalse(task.isCancelled());
590              p1.shutdown();

Diff Legend

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