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.4 by dl, Sun Sep 14 20:42:40 2003 UTC vs.
Revision 1.44 by jsr166, Sat May 28 15:33:20 2011 UTC

# Line 1 | Line 1
1   /*
2 < * Written by members of JCP JSR-166 Expert Group and released to the
3 < * public domain. Use, modify, and redistribute this code in any way
4 < * without acknowledgement. Other contributors include Andrew Wright,
5 < * Jeffrey Hayes, Pat Fischer, Mike Judd.
2 > * Written by Doug Lea with assistance from members of JCP JSR-166
3 > * Expert Group and released to the public domain, as explained at
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9   import junit.framework.*;
10   import java.util.*;
11   import java.util.concurrent.*;
12 + import static java.util.concurrent.TimeUnit.MILLISECONDS;
13 + import java.util.concurrent.atomic.*;
14  
15   public class ScheduledExecutorTest extends JSR166TestCase {
16      public static void main(String[] args) {
17 <        junit.textui.TestRunner.run (suite());  
17 >        junit.textui.TestRunner.run(suite());
18      }
19      public static Test suite() {
20 <        return new TestSuite(ScheduledExecutorTest.class);
20 >        return new TestSuite(ScheduledExecutorTest.class);
21      }
22  
23 <    static class MyRunnable implements Runnable {
24 <        volatile boolean done = false;
25 <        public void run(){
26 <            try{
27 <                Thread.sleep(SMALL_DELAY_MS);
28 <                done = true;
29 <            } catch(Exception e){
30 <            }
23 >    /**
24 >     * execute successfully executes a runnable
25 >     */
26 >    public void testExecute() throws InterruptedException {
27 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
28 >        final CountDownLatch done = new CountDownLatch(1);
29 >        final Runnable task = new CheckedRunnable() {
30 >            public void realRun() {
31 >                done.countDown();
32 >            }};
33 >        try {
34 >            p.execute(task);
35 >            assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
36 >        } finally {
37 >            joinPool(p);
38          }
39      }
40  
41 <    static class MyCallable implements Callable {
42 <        volatile boolean done = false;
43 <        public Object call(){
44 <            try{
45 <                Thread.sleep(SMALL_DELAY_MS);
46 <                done = true;
47 <            }catch(Exception e){}
48 <            return Boolean.TRUE;
41 >    /**
42 >     * delayed schedule of callable successfully executes after delay
43 >     */
44 >    public void testSchedule1() throws Exception {
45 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
46 >        final long startTime = System.nanoTime();
47 >        final CountDownLatch done = new CountDownLatch(1);
48 >        try {
49 >            Callable task = new CheckedCallable<Boolean>() {
50 >                public Boolean realCall() {
51 >                    done.countDown();
52 >                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
53 >                    return Boolean.TRUE;
54 >                }};
55 >            Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
56 >            assertSame(Boolean.TRUE, f.get());
57 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
58 >            assertTrue(done.await(0L, MILLISECONDS));
59 >        } finally {
60 >            joinPool(p);
61          }
62      }
63  
64 <    public void testExecute(){
65 <        try{
66 <            MyRunnable runnable =new MyRunnable();
67 <            ScheduledExecutor one = new ScheduledExecutor(1);
68 <            one.execute(runnable);
69 <            assertFalse(runnable.done);
70 <            Thread.sleep(SHORT_DELAY_MS);
71 <            one.shutdown();
72 <            try{
73 <                Thread.sleep(MEDIUM_DELAY_MS);
74 <            } catch(InterruptedException e){
75 <                fail("unexpected exception");
76 <            }
77 <            assertTrue(runnable.done);
78 <            one.shutdown();
79 <            joinPool(one);
80 <        }
81 <        catch(Exception e){
82 <            fail("unexpected exception");
61 <        }
62 <        
63 <    }
64 <
65 <    public void testSchedule1(){
66 <        try{
67 <            MyCallable callable = new MyCallable();
68 <            ScheduledExecutor one = new ScheduledExecutor(1);
69 <            Future f = one.schedule(callable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
70 <            assertFalse(callable.done);
71 <            Thread.sleep(MEDIUM_DELAY_MS);
72 <            assertTrue(callable.done);
73 <            assertEquals(Boolean.TRUE, f.get());
74 <            one.shutdown();
75 <            joinPool(one);
76 <        }catch(RejectedExecutionException e){}
77 <        catch(Exception e){
78 <            fail("unexpected exception");
79 <        }
80 <    }
81 <
82 <    /**
83 <     *  Another version of schedule, only using Runnable instead of Callable
84 <     */
85 <    public void testSchedule3(){
86 <        try{
87 <            MyRunnable runnable = new MyRunnable();
88 <            ScheduledExecutor one = new ScheduledExecutor(1);
89 <            one.schedule(runnable, SMALL_DELAY_MS, TimeUnit.MILLISECONDS);
90 <            Thread.sleep(SHORT_DELAY_MS);
91 <            assertFalse(runnable.done);
92 <            Thread.sleep(MEDIUM_DELAY_MS);
93 <            assertTrue(runnable.done);
94 <            one.shutdown();
95 <            joinPool(one);
96 <        } catch(Exception e){
97 <            fail("unexpected exception");
98 <        }
99 <    }
100 <    
101 <    /**
102 <     *  The final version of schedule, using both long, TimeUnit and Runnable
103 <     */
104 <    public void testSchedule4(){
105 <        try{
106 <            MyRunnable runnable = new MyRunnable();
107 <            ScheduledExecutor one = new ScheduledExecutor(1);
108 <            one.schedule(runnable, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
109 <            assertFalse(runnable.done);
110 <            Thread.sleep(MEDIUM_DELAY_MS);
111 <            assertTrue(runnable.done);
112 <            one.shutdown();
113 <            joinPool(one);
114 <        } catch(Exception e){
115 <            fail("unexpected exception");
116 <        }
117 <    }
118 <    
119 <  
120 <    // exception tests
121 <
122 <    /**
123 <     *   schedule(Runnable, long) throws RejectedExecutionException
124 <     *  This occurs on an attempt to schedule a task on a shutdown executor
125 <     */
126 <    public void testSchedule1_RejectedExecutionException(){
127 <        ScheduledExecutor se = new ScheduledExecutor(1);
128 <        try{
129 <            se.shutdown();
130 <            se.schedule(new NoOpRunnable(),
131 <                        MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
132 <            fail("shoud throw");
133 <        } catch(RejectedExecutionException success){
64 >    /**
65 >     * delayed schedule of runnable successfully executes after delay
66 >     */
67 >    public void testSchedule3() throws Exception {
68 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
69 >        final long startTime = System.nanoTime();
70 >        final CountDownLatch done = new CountDownLatch(1);
71 >        try {
72 >            Runnable task = new CheckedRunnable() {
73 >                public void realRun() {
74 >                    done.countDown();
75 >                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
76 >                }};
77 >            Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
78 >            await(done);
79 >            assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
80 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
81 >        } finally {
82 >            joinPool(p);
83          }
84 +    }
85 +
86 +    /**
87 +     * scheduleAtFixedRate executes runnable after given initial delay
88 +     */
89 +    public void testSchedule4() throws Exception {
90 +        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
91 +        final long startTime = System.nanoTime();
92 +        final CountDownLatch done = new CountDownLatch(1);
93 +        try {
94 +            Runnable task = new CheckedRunnable() {
95 +                public void realRun() {
96 +                    done.countDown();
97 +                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
98 +                }};
99 +            ScheduledFuture f =
100 +                p.scheduleAtFixedRate(task, timeoutMillis(),
101 +                                      LONG_DELAY_MS, MILLISECONDS);
102 +            await(done);
103 +            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
104 +            f.cancel(true);
105 +        } finally {
106 +            joinPool(p);
107 +        }
108 +    }
109 +
110 +    /**
111 +     * scheduleWithFixedDelay executes runnable after given initial delay
112 +     */
113 +    public void testSchedule5() throws Exception {
114 +        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
115 +        final long startTime = System.nanoTime();
116 +        final CountDownLatch done = new CountDownLatch(1);
117 +        try {
118 +            Runnable task = new CheckedRunnable() {
119 +                public void realRun() {
120 +                    done.countDown();
121 +                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
122 +                }};
123 +            ScheduledFuture f =
124 +                p.scheduleWithFixedDelay(task, timeoutMillis(),
125 +                                         LONG_DELAY_MS, MILLISECONDS);
126 +            await(done);
127 +            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
128 +            f.cancel(true);
129 +        } finally {
130 +            joinPool(p);
131 +        }
132 +    }
133 +
134 +    static class RunnableCounter implements Runnable {
135 +        AtomicInteger count = new AtomicInteger(0);
136 +        public void run() { count.getAndIncrement(); }
137 +    }
138 +
139 +    /**
140 +     * scheduleAtFixedRate executes series of tasks at given rate
141 +     */
142 +    public void testFixedRateSequence() throws InterruptedException {
143 +        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
144 +        RunnableCounter counter = new RunnableCounter();
145 +        ScheduledFuture h =
146 +            p.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS);
147 +        delay(SMALL_DELAY_MS);
148 +        h.cancel(true);
149 +        int c = counter.count.get();
150 +        // By time scaling conventions, we must have at least
151 +        // an execution per SHORT delay, but no more than one SHORT more
152 +        assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
153 +        assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
154 +        joinPool(p);
155 +    }
156 +
157 +    /**
158 +     * scheduleWithFixedDelay executes series of tasks with given period
159 +     */
160 +    public void testFixedDelaySequence() throws InterruptedException {
161 +        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
162 +        RunnableCounter counter = new RunnableCounter();
163 +        ScheduledFuture h =
164 +            p.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS);
165 +        delay(SMALL_DELAY_MS);
166 +        h.cancel(true);
167 +        int c = counter.count.get();
168 +        assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
169 +        assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
170 +        joinPool(p);
171 +    }
172 +
173 +    /**
174 +     * execute(null) throws NPE
175 +     */
176 +    public void testExecuteNull() throws InterruptedException {
177 +        ScheduledThreadPoolExecutor se = null;
178 +        try {
179 +            se = new ScheduledThreadPoolExecutor(1);
180 +            se.execute(null);
181 +            shouldThrow();
182 +        } catch (NullPointerException success) {}
183 +
184          joinPool(se);
185 +    }
186  
187 +    /**
188 +     * schedule(null) throws NPE
189 +     */
190 +    public void testScheduleNull() throws InterruptedException {
191 +        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
192 +        try {
193 +            TrackedCallable callable = null;
194 +            Future f = se.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
195 +            shouldThrow();
196 +        } catch (NullPointerException success) {}
197 +        joinPool(se);
198      }
199  
200      /**
201 <     *   schedule(Callable, long, TimeUnit) throws RejectedExecutionException
141 <     *  This occurs on an attempt to schedule a task on a shutdown executor
201 >     * execute throws RejectedExecutionException if shutdown
202       */
203 <    public void testSchedule2_RejectedExecutionException(){
204 <        ScheduledExecutor se = new ScheduledExecutor(1);
205 <        try{
203 >    public void testSchedule1_RejectedExecutionException() throws InterruptedException {
204 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
205 >        try {
206              se.shutdown();
207 <            se.schedule(new NoOpCallable(),
208 <                        MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
209 <            fail("should throw");
210 <        } catch(RejectedExecutionException success){
207 >            se.schedule(new NoOpRunnable(),
208 >                        MEDIUM_DELAY_MS, MILLISECONDS);
209 >            shouldThrow();
210 >        } catch (RejectedExecutionException success) {
211 >        } catch (SecurityException ok) {
212          }
213 +
214          joinPool(se);
215      }
216  
217      /**
218 <     *   schedule(Callable, long) throws RejectedExecutionException
157 <     *  This occurs on an attempt to schedule a task on a shutdown executor
218 >     * schedule throws RejectedExecutionException if shutdown
219       */
220 <     public void testSchedule3_RejectedExecutionException(){
221 <         ScheduledExecutor se = new ScheduledExecutor(1);
222 <         try{
220 >    public void testSchedule2_RejectedExecutionException() throws InterruptedException {
221 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
222 >        try {
223              se.shutdown();
224              se.schedule(new NoOpCallable(),
225 <                        MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
226 <            fail("should throw");
227 <        } catch(RejectedExecutionException success){
228 <        }
229 <         joinPool(se);
225 >                        MEDIUM_DELAY_MS, MILLISECONDS);
226 >            shouldThrow();
227 >        } catch (RejectedExecutionException success) {
228 >        } catch (SecurityException ok) {
229 >        }
230 >        joinPool(se);
231      }
232  
233      /**
234 <     *   scheduleAtFixedRate(Runnable, long, long, TimeUnit) throws
173 <     *  RejectedExecutionException.
174 <     *  This occurs on an attempt to schedule a task on a shutdown executor
234 >     * schedule callable throws RejectedExecutionException if shutdown
235       */
236 <    public void testScheduleAtFixedRate1_RejectedExecutionException(){
237 <        ScheduledExecutor se = new ScheduledExecutor(1);
238 <        try{
236 >    public void testSchedule3_RejectedExecutionException() throws InterruptedException {
237 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
238 >        try {
239              se.shutdown();
240 <            se.scheduleAtFixedRate(new NoOpRunnable(),
241 <                                   MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
242 <            fail("should throw");
243 <        } catch(RejectedExecutionException success){
244 <        }
240 >            se.schedule(new NoOpCallable(),
241 >                        MEDIUM_DELAY_MS, MILLISECONDS);
242 >            shouldThrow();
243 >        } catch (RejectedExecutionException success) {
244 >        } catch (SecurityException ok) {
245 >        }
246          joinPool(se);
247      }
248 <    
248 >
249      /**
250 <     *   scheduleAtFixedRate(Runnable, long, long, TimeUnit) throws
251 <     *  RejectedExecutionException.
252 <     *  This occurs on an attempt to schedule a task on a shutdown executor
253 <     */
254 <    public void testScheduleAtFixedRate2_RejectedExecutionException(){
194 <        ScheduledExecutor se = new ScheduledExecutor(1);
195 <        try{
250 >     * scheduleAtFixedRate throws RejectedExecutionException if shutdown
251 >     */
252 >    public void testScheduleAtFixedRate1_RejectedExecutionException() throws InterruptedException {
253 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
254 >        try {
255              se.shutdown();
256              se.scheduleAtFixedRate(new NoOpRunnable(),
257 <                                   1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
258 <            fail("should throw");
259 <        } catch(RejectedExecutionException success){
260 <        }
257 >                                   MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS);
258 >            shouldThrow();
259 >        } catch (RejectedExecutionException success) {
260 >        } catch (SecurityException ok) {
261 >        }
262          joinPool(se);
263      }
264  
265      /**
266 <     *   scheduleWithFixedDelay(Runnable, long, long, TimeUnit) throws
267 <     *  RejectedExecutionException.
268 <     *  This occurs on an attempt to schedule a task on a shutdown executor
269 <     */
270 <    public void testScheduleWithFixedDelay1_RejectedExecutionException(){
211 <        ScheduledExecutor se = new ScheduledExecutor(1);
212 <        try{
266 >     * scheduleWithFixedDelay throws RejectedExecutionException if shutdown
267 >     */
268 >    public void testScheduleWithFixedDelay1_RejectedExecutionException() throws InterruptedException {
269 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
270 >        try {
271              se.shutdown();
272              se.scheduleWithFixedDelay(new NoOpRunnable(),
273 <                                      MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
274 <            fail("should throw");
275 <        } catch(RejectedExecutionException success){
276 <        }
273 >                                      MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS);
274 >            shouldThrow();
275 >        } catch (RejectedExecutionException success) {
276 >        } catch (SecurityException ok) {
277 >        }
278          joinPool(se);
279      }
280  
281      /**
282 <     *   scheduleWithFixedDelay(Runnable, long, long, TimeUnit) throws
283 <     *  RejectedExecutionException.
284 <     *  This occurs on an attempt to schedule a task on a shutdown executor
285 <     */
286 <     public void testScheduleWithFixedDelay2_RejectedExecutionException(){
287 <         ScheduledExecutor se = new ScheduledExecutor(1);
288 <        try{
289 <            se.shutdown();
290 <            se.scheduleWithFixedDelay(new NoOpRunnable(),
291 <                                      1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
292 <            fail("should throw");
293 <        } catch(RejectedExecutionException success){
294 <        }
295 <        joinPool(se);
282 >     * getActiveCount increases but doesn't overestimate, when a
283 >     * thread becomes active
284 >     */
285 >    public void testGetActiveCount() throws InterruptedException {
286 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(2);
287 >        final CountDownLatch threadStarted = new CountDownLatch(1);
288 >        final CountDownLatch done = new CountDownLatch(1);
289 >        try {
290 >            assertEquals(0, p.getActiveCount());
291 >            p.execute(new CheckedRunnable() {
292 >                public void realRun() throws InterruptedException {
293 >                    threadStarted.countDown();
294 >                    assertEquals(1, p.getActiveCount());
295 >                    done.await();
296 >                }});
297 >            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
298 >            assertEquals(1, p.getActiveCount());
299 >        } finally {
300 >            done.countDown();
301 >            joinPool(p);
302 >        }
303      }
304  
305      /**
306 <     *   execute throws RejectedExecutionException
307 <     *  This occurs on an attempt to schedule a task on a shutdown executor
306 >     * getCompletedTaskCount increases, but doesn't overestimate,
307 >     * when tasks complete
308       */
309 <    public void testExecute_RejectedExecutionException(){
310 <        ScheduledExecutor se = new ScheduledExecutor(1);
311 <        try{
312 <            se.shutdown();
313 <            se.execute(new NoOpRunnable());
314 <            fail("should throw");
315 <        } catch(RejectedExecutionException success){
316 <        }
317 <        joinPool(se);
309 >    public void testGetCompletedTaskCount() throws InterruptedException {
310 >        final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(2);
311 >        final CountDownLatch threadStarted = new CountDownLatch(1);
312 >        final CountDownLatch threadProceed = new CountDownLatch(1);
313 >        final CountDownLatch threadDone = new CountDownLatch(1);
314 >        try {
315 >            assertEquals(0, p.getCompletedTaskCount());
316 >            p.execute(new CheckedRunnable() {
317 >                public void realRun() throws InterruptedException {
318 >                    threadStarted.countDown();
319 >                    assertEquals(0, p.getCompletedTaskCount());
320 >                    threadProceed.await();
321 >                    threadDone.countDown();
322 >                }});
323 >            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
324 >            assertEquals(0, p.getCompletedTaskCount());
325 >            threadProceed.countDown();
326 >            threadDone.await();
327 >            long startTime = System.nanoTime();
328 >            while (p.getCompletedTaskCount() != 1) {
329 >                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
330 >                    fail("timed out");
331 >                Thread.yield();
332 >            }
333 >        } finally {
334 >            joinPool(p);
335 >        }
336 >    }
337 >
338 >    /**
339 >     * getCorePoolSize returns size given in constructor if not otherwise set
340 >     */
341 >    public void testGetCorePoolSize() throws InterruptedException {
342 >        ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
343 >        assertEquals(1, p.getCorePoolSize());
344 >        joinPool(p);
345      }
346  
347      /**
348 <     *   getActiveCount gives correct values
348 >     * getLargestPoolSize increases, but doesn't overestimate, when
349 >     * multiple threads active
350       */
351 <    public void testGetActiveCount(){
352 <        ScheduledExecutor two = new ScheduledExecutor(2);
353 <        assertEquals(0, two.getActiveCount());
354 <        two.execute(new SmallRunnable());
355 <        try{
356 <            Thread.sleep(SHORT_DELAY_MS);
357 <        } catch(Exception e){
358 <            fail("unexpected exception");
351 >    public void testGetLargestPoolSize() throws InterruptedException {
352 >        final int THREADS = 3;
353 >        final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(THREADS);
354 >        final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
355 >        final CountDownLatch done = new CountDownLatch(1);
356 >        try {
357 >            assertEquals(0, p.getLargestPoolSize());
358 >            for (int i = 0; i < THREADS; i++)
359 >                p.execute(new CheckedRunnable() {
360 >                    public void realRun() throws InterruptedException {
361 >                        threadsStarted.countDown();
362 >                        done.await();
363 >                        assertEquals(THREADS, p.getLargestPoolSize());
364 >                    }});
365 >            assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS));
366 >            assertEquals(THREADS, p.getLargestPoolSize());
367 >        } finally {
368 >            done.countDown();
369 >            joinPool(p);
370 >            assertEquals(THREADS, p.getLargestPoolSize());
371          }
266        assertEquals(1, two.getActiveCount());
267        joinPool(two);
372      }
373 <    
373 >
374      /**
375 <     *   getCompleteTaskCount gives correct values
375 >     * getPoolSize increases, but doesn't overestimate, when threads
376 >     * become active
377       */
378 <    public void testGetCompletedTaskCount(){
379 <        ScheduledExecutor two = new ScheduledExecutor(2);
380 <        assertEquals(0, two.getCompletedTaskCount());
381 <        two.execute(new SmallRunnable());
382 <        try{
383 <            Thread.sleep(MEDIUM_DELAY_MS);
384 <        } catch(Exception e){
385 <            fail("unexpected exception");
378 >    public void testGetPoolSize() throws InterruptedException {
379 >        final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
380 >        final CountDownLatch threadStarted = new CountDownLatch(1);
381 >        final CountDownLatch done = new CountDownLatch(1);
382 >        try {
383 >            assertEquals(0, p.getPoolSize());
384 >            p.execute(new CheckedRunnable() {
385 >                public void realRun() throws InterruptedException {
386 >                    threadStarted.countDown();
387 >                    assertEquals(1, p.getPoolSize());
388 >                    done.await();
389 >                }});
390 >            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
391 >            assertEquals(1, p.getPoolSize());
392 >        } finally {
393 >            done.countDown();
394 >            joinPool(p);
395          }
282        assertEquals(1, two.getCompletedTaskCount());
283        joinPool(two);
396      }
397 <    
397 >
398      /**
399 <     *   getCorePoolSize gives correct values
399 >     * getTaskCount increases, but doesn't overestimate, when tasks
400 >     * submitted
401       */
402 <    public void testGetCorePoolSize(){
403 <        ScheduledExecutor one = new ScheduledExecutor(1);
404 <        assertEquals(1, one.getCorePoolSize());
405 <        joinPool(one);
402 >    public void testGetTaskCount() throws InterruptedException {
403 >        final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
404 >        final CountDownLatch threadStarted = new CountDownLatch(1);
405 >        final CountDownLatch done = new CountDownLatch(1);
406 >        final int TASKS = 5;
407 >        try {
408 >            assertEquals(0, p.getTaskCount());
409 >            for (int i = 0; i < TASKS; i++)
410 >                p.execute(new CheckedRunnable() {
411 >                    public void realRun() throws InterruptedException {
412 >                        threadStarted.countDown();
413 >                        done.await();
414 >                    }});
415 >            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
416 >            assertEquals(TASKS, p.getTaskCount());
417 >        } finally {
418 >            done.countDown();
419 >            joinPool(p);
420 >        }
421 >    }
422 >
423 >    /**
424 >     * getThreadFactory returns factory in constructor if not set
425 >     */
426 >    public void testGetThreadFactory() throws InterruptedException {
427 >        ThreadFactory tf = new SimpleThreadFactory();
428 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1, tf);
429 >        assertSame(tf, p.getThreadFactory());
430 >        joinPool(p);
431      }
432 <    
432 >
433      /**
434 <     *   getLargestPoolSize gives correct values
434 >     * setThreadFactory sets the thread factory returned by getThreadFactory
435       */
436 <    public void testGetLargestPoolSize(){
437 <        ScheduledExecutor two = new ScheduledExecutor(2);
438 <        assertEquals(0, two.getLargestPoolSize());
439 <        two.execute(new SmallRunnable());
440 <        two.execute(new SmallRunnable());
441 <        try{
442 <            Thread.sleep(SHORT_DELAY_MS);
443 <        } catch(Exception e){
444 <            fail("unexpected exception");
436 >    public void testSetThreadFactory() throws InterruptedException {
437 >        ThreadFactory tf = new SimpleThreadFactory();
438 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
439 >        p.setThreadFactory(tf);
440 >        assertSame(tf, p.getThreadFactory());
441 >        joinPool(p);
442 >    }
443 >
444 >    /**
445 >     * setThreadFactory(null) throws NPE
446 >     */
447 >    public void testSetThreadFactoryNull() throws InterruptedException {
448 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
449 >        try {
450 >            p.setThreadFactory(null);
451 >            shouldThrow();
452 >        } catch (NullPointerException success) {
453 >        } finally {
454 >            joinPool(p);
455          }
308        assertEquals(2, two.getLargestPoolSize());
309        joinPool(two);
456      }
457 <    
457 >
458      /**
459 <     *   getPoolSize gives correct values
459 >     * isShutdown is false before shutdown, true after
460       */
461 <    public void testGetPoolSize(){
462 <        ScheduledExecutor one = new ScheduledExecutor(1);
463 <        assertEquals(0, one.getPoolSize());
464 <        one.execute(new SmallRunnable());
465 <        assertEquals(1, one.getPoolSize());
466 <        joinPool(one);
461 >    public void testIsShutdown() {
462 >
463 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
464 >        try {
465 >            assertFalse(p.isShutdown());
466 >        }
467 >        finally {
468 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
469 >        }
470 >        assertTrue(p.isShutdown());
471      }
472 <    
472 >
473      /**
474 <     *   getTaskCount gives correct values
474 >     * isTerminated is false before termination, true after
475       */
476 <    public void testGetTaskCount(){
477 <        ScheduledExecutor one = new ScheduledExecutor(1);
478 <        assertEquals(0, one.getTaskCount());
479 <        for(int i = 0; i < 5; i++)
480 <            one.execute(new SmallRunnable());
481 <        try{
482 <            Thread.sleep(SHORT_DELAY_MS);
483 <        } catch(Exception e){
484 <            fail("unexpected exception");
476 >    public void testIsTerminated() throws InterruptedException {
477 >        final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
478 >        final CountDownLatch threadStarted = new CountDownLatch(1);
479 >        final CountDownLatch done = new CountDownLatch(1);
480 >        assertFalse(p.isTerminated());
481 >        try {
482 >            p.execute(new CheckedRunnable() {
483 >                public void realRun() throws InterruptedException {
484 >                    assertFalse(p.isTerminated());
485 >                    threadStarted.countDown();
486 >                    done.await();
487 >                }});
488 >            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
489 >            assertFalse(p.isTerminating());
490 >            done.countDown();
491 >        } finally {
492 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
493          }
494 <        assertEquals(5, one.getTaskCount());
495 <        joinPool(one);
494 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
495 >        assertTrue(p.isTerminated());
496      }
497 <    
497 >
498      /**
499 <     *   isShutDown gives correct values
499 >     * isTerminating is not true when running or when terminated
500       */
501 <    public void testIsShutdown(){
502 <        
503 <        ScheduledExecutor one = new ScheduledExecutor(1);
501 >    public void testIsTerminating() throws InterruptedException {
502 >        final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
503 >        final CountDownLatch threadStarted = new CountDownLatch(1);
504 >        final CountDownLatch done = new CountDownLatch(1);
505          try {
506 <            assertFalse(one.isShutdown());
506 >            assertFalse(p.isTerminating());
507 >            p.execute(new CheckedRunnable() {
508 >                public void realRun() throws InterruptedException {
509 >                    assertFalse(p.isTerminating());
510 >                    threadStarted.countDown();
511 >                    done.await();
512 >                }});
513 >            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
514 >            assertFalse(p.isTerminating());
515 >            done.countDown();
516 >        } finally {
517 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
518 >        }
519 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
520 >        assertTrue(p.isTerminated());
521 >        assertFalse(p.isTerminating());
522 >    }
523 >
524 >    /**
525 >     * getQueue returns the work queue, which contains queued tasks
526 >     */
527 >    public void testGetQueue() throws InterruptedException {
528 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
529 >        final CountDownLatch threadStarted = new CountDownLatch(1);
530 >        final CountDownLatch done = new CountDownLatch(1);
531 >        try {
532 >            ScheduledFuture[] tasks = new ScheduledFuture[5];
533 >            for (int i = 0; i < tasks.length; i++) {
534 >                Runnable r = new CheckedRunnable() {
535 >                    public void realRun() throws InterruptedException {
536 >                        threadStarted.countDown();
537 >                        done.await();
538 >                    }};
539 >                tasks[i] = p.schedule(r, 1, MILLISECONDS);
540 >            }
541 >            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
542 >            BlockingQueue<Runnable> q = p.getQueue();
543 >            assertTrue(q.contains(tasks[tasks.length - 1]));
544 >            assertFalse(q.contains(tasks[0]));
545 >        } finally {
546 >            done.countDown();
547 >            joinPool(p);
548 >        }
549 >    }
550 >
551 >    /**
552 >     * remove(task) removes queued task, and fails to remove active task
553 >     */
554 >    public void testRemove() throws InterruptedException {
555 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
556 >        ScheduledFuture[] tasks = new ScheduledFuture[5];
557 >        final CountDownLatch threadStarted = new CountDownLatch(1);
558 >        final CountDownLatch done = new CountDownLatch(1);
559 >        try {
560 >            for (int i = 0; i < tasks.length; i++) {
561 >                Runnable r = new CheckedRunnable() {
562 >                    public void realRun() throws InterruptedException {
563 >                        threadStarted.countDown();
564 >                        done.await();
565 >                    }};
566 >                tasks[i] = p.schedule(r, 1, MILLISECONDS);
567 >            }
568 >            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
569 >            BlockingQueue<Runnable> q = p.getQueue();
570 >            assertFalse(p.remove((Runnable)tasks[0]));
571 >            assertTrue(q.contains((Runnable)tasks[4]));
572 >            assertTrue(q.contains((Runnable)tasks[3]));
573 >            assertTrue(p.remove((Runnable)tasks[4]));
574 >            assertFalse(p.remove((Runnable)tasks[4]));
575 >            assertFalse(q.contains((Runnable)tasks[4]));
576 >            assertTrue(q.contains((Runnable)tasks[3]));
577 >            assertTrue(p.remove((Runnable)tasks[3]));
578 >            assertFalse(q.contains((Runnable)tasks[3]));
579 >        } finally {
580 >            done.countDown();
581 >            joinPool(p);
582 >        }
583 >    }
584 >
585 >    /**
586 >     * purge eventually removes cancelled tasks from the queue
587 >     */
588 >    public void testPurge() throws InterruptedException {
589 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
590 >        ScheduledFuture[] tasks = new ScheduledFuture[5];
591 >        for (int i = 0; i < tasks.length; i++)
592 >            tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
593 >                                  LONG_DELAY_MS, MILLISECONDS);
594 >        try {
595 >            int max = tasks.length;
596 >            if (tasks[4].cancel(true)) --max;
597 >            if (tasks[3].cancel(true)) --max;
598 >            // There must eventually be an interference-free point at
599 >            // which purge will not fail. (At worst, when queue is empty.)
600 >            long startTime = System.nanoTime();
601 >            do {
602 >                p.purge();
603 >                long count = p.getTaskCount();
604 >                if (count == max)
605 >                    return;
606 >            } while (millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
607 >            fail("Purge failed to remove cancelled tasks");
608 >        } finally {
609 >            for (ScheduledFuture task : tasks)
610 >                task.cancel(true);
611 >            joinPool(p);
612 >        }
613 >    }
614 >
615 >    /**
616 >     * shutdownNow returns a list containing tasks that were not run
617 >     */
618 >    public void testShutdownNow() {
619 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
620 >        for (int i = 0; i < 5; i++)
621 >            p.schedule(new SmallPossiblyInterruptedRunnable(),
622 >                       LONG_DELAY_MS, MILLISECONDS);
623 >        try {
624 >            List<Runnable> l = p.shutdownNow();
625 >            assertTrue(p.isShutdown());
626 >            assertEquals(5, l.size());
627 >        } catch (SecurityException ok) {
628 >            // Allowed in case test doesn't have privs
629 >        } finally {
630 >            joinPool(p);
631 >        }
632 >    }
633 >
634 >    /**
635 >     * In default setting, shutdown cancels periodic but not delayed
636 >     * tasks at shutdown
637 >     */
638 >    public void testShutdown1() throws InterruptedException {
639 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
640 >        assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
641 >        assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
642 >
643 >        ScheduledFuture[] tasks = new ScheduledFuture[5];
644 >        for (int i = 0; i < tasks.length; i++)
645 >            tasks[i] = p.schedule(new NoOpRunnable(),
646 >                                  SHORT_DELAY_MS, MILLISECONDS);
647 >        try { p.shutdown(); } catch (SecurityException ok) { return; }
648 >        BlockingQueue<Runnable> q = p.getQueue();
649 >        for (ScheduledFuture task : tasks) {
650 >            assertFalse(task.isDone());
651 >            assertFalse(task.isCancelled());
652 >            assertTrue(q.contains(task));
653 >        }
654 >        assertTrue(p.isShutdown());
655 >        assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
656 >        assertTrue(p.isTerminated());
657 >        for (ScheduledFuture task : tasks) {
658 >            assertTrue(task.isDone());
659 >            assertFalse(task.isCancelled());
660 >        }
661 >    }
662 >
663 >    /**
664 >     * If setExecuteExistingDelayedTasksAfterShutdownPolicy is false,
665 >     * delayed tasks are cancelled at shutdown
666 >     */
667 >    public void testShutdown2() throws InterruptedException {
668 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
669 >        p.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
670 >        assertFalse(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
671 >        assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
672 >        ScheduledFuture[] tasks = new ScheduledFuture[5];
673 >        for (int i = 0; i < tasks.length; i++)
674 >            tasks[i] = p.schedule(new NoOpRunnable(),
675 >                                  SHORT_DELAY_MS, MILLISECONDS);
676 >        BlockingQueue q = p.getQueue();
677 >        assertEquals(tasks.length, q.size());
678 >        try { p.shutdown(); } catch (SecurityException ok) { return; }
679 >        assertTrue(p.isShutdown());
680 >        assertTrue(q.isEmpty());
681 >        assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
682 >        assertTrue(p.isTerminated());
683 >        for (ScheduledFuture task : tasks) {
684 >            assertTrue(task.isDone());
685 >            assertTrue(task.isCancelled());
686 >        }
687 >    }
688 >
689 >    /**
690 >     * If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
691 >     * periodic tasks are cancelled at shutdown
692 >     */
693 >    public void testShutdown3() throws InterruptedException {
694 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
695 >        assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
696 >        assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
697 >        p.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
698 >        assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
699 >        assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
700 >        long initialDelay = LONG_DELAY_MS;
701 >        ScheduledFuture task =
702 >            p.scheduleAtFixedRate(new NoOpRunnable(), initialDelay,
703 >                                  5, MILLISECONDS);
704 >        try { p.shutdown(); } catch (SecurityException ok) { return; }
705 >        assertTrue(p.isShutdown());
706 >        assertTrue(p.getQueue().isEmpty());
707 >        assertTrue(task.isDone());
708 >        assertTrue(task.isCancelled());
709 >        joinPool(p);
710 >    }
711 >
712 >    /**
713 >     * if setContinueExistingPeriodicTasksAfterShutdownPolicy is true,
714 >     * periodic tasks are not cancelled at shutdown
715 >     */
716 >    public void testShutdown4() throws InterruptedException {
717 >        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
718 >        final CountDownLatch counter = new CountDownLatch(2);
719 >        try {
720 >            p.setContinueExistingPeriodicTasksAfterShutdownPolicy(true);
721 >            assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
722 >            assertTrue(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
723 >            final Runnable r = new CheckedRunnable() {
724 >                public void realRun() {
725 >                    counter.countDown();
726 >                }};
727 >            ScheduledFuture task =
728 >                p.scheduleAtFixedRate(r, 1, 1, MILLISECONDS);
729 >            assertFalse(task.isDone());
730 >            assertFalse(task.isCancelled());
731 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
732 >            assertFalse(task.isCancelled());
733 >            assertFalse(p.isTerminated());
734 >            assertTrue(p.isShutdown());
735 >            assertTrue(counter.await(SMALL_DELAY_MS, MILLISECONDS));
736 >            assertFalse(task.isCancelled());
737 >            assertTrue(task.cancel(false));
738 >            assertTrue(task.isDone());
739 >            assertTrue(task.isCancelled());
740 >            assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
741 >            assertTrue(p.isTerminated());
742          }
743          finally {
744 <            one.shutdown();
744 >            joinPool(p);
745          }
352        assertTrue(one.isShutdown());
746      }
747  
355        
748      /**
749 <     *   isTerminated gives correct values
358 <     *  Makes sure termination does not take an innapropriate
359 <     *  amount of time
749 >     * completed submit of callable returns result
750       */
751 <    public void testIsTerminated(){
752 <        ScheduledExecutor one = new ScheduledExecutor(1);
751 >    public void testSubmitCallable() throws Exception {
752 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
753          try {
754 <            one.execute(new SmallRunnable());
754 >            Future<String> future = e.submit(new StringTask());
755 >            String result = future.get();
756 >            assertSame(TEST_STRING, result);
757          } finally {
758 <            one.shutdown();
758 >            joinPool(e);
759          }
760 +    }
761 +
762 +    /**
763 +     * completed submit of runnable returns successfully
764 +     */
765 +    public void testSubmitRunnable() throws Exception {
766 +        ExecutorService e = new ScheduledThreadPoolExecutor(2);
767          try {
768 <            assertTrue(one.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
769 <            assertTrue(one.isTerminated());
770 <        } catch(Exception e){
771 <            fail("unexpected exception");
772 <        }      
768 >            Future<?> future = e.submit(new NoOpRunnable());
769 >            future.get();
770 >            assertTrue(future.isDone());
771 >        } finally {
772 >            joinPool(e);
773 >        }
774      }
775  
776      /**
777 <     *   that purge correctly removes cancelled tasks
378 <     *  from the queue
777 >     * completed submit of (runnable, result) returns result
778       */
779 <    public void testPurge(){
780 <        ScheduledExecutor one = new ScheduledExecutor(1);
781 <        ScheduledCancellable[] tasks = new ScheduledCancellable[5];
782 <        for(int i = 0; i < 5; i++){
783 <            tasks[i] = one.schedule(new SmallRunnable(), 1, TimeUnit.MILLISECONDS);
779 >    public void testSubmitRunnable2() throws Exception {
780 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
781 >        try {
782 >            Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
783 >            String result = future.get();
784 >            assertSame(TEST_STRING, result);
785 >        } finally {
786 >            joinPool(e);
787          }
386        int max = 5;
387        if (tasks[4].cancel(true)) --max;
388        if (tasks[3].cancel(true)) --max;
389        one.purge();
390        long count = one.getTaskCount();
391        assertTrue(count > 0 && count <= max);
392        joinPool(one);
788      }
789  
790      /**
791 <     *   shutDownNow returns a list
397 <     *  containing the correct number of elements
791 >     * invokeAny(null) throws NPE
792       */
793 <    public void testShutDownNow(){
794 <        ScheduledExecutor one = new ScheduledExecutor(1);
795 <        for(int i = 0; i < 5; i++)
796 <            one.schedule(new SmallRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
797 <        List l = one.shutdownNow();
798 <        assertTrue(one.isShutdown());
799 <        assertTrue(l.size() > 0 && l.size() <= 5);
800 <        joinPool(one);
793 >    public void testInvokeAny1() throws Exception {
794 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
795 >        try {
796 >            e.invokeAny(null);
797 >            shouldThrow();
798 >        } catch (NullPointerException success) {
799 >        } finally {
800 >            joinPool(e);
801 >        }
802      }
803  
804 <    public void testShutDown1(){
804 >    /**
805 >     * invokeAny(empty collection) throws IAE
806 >     */
807 >    public void testInvokeAny2() throws Exception {
808 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
809          try {
810 <            ScheduledExecutor one = new ScheduledExecutor(1);
811 <            assertTrue(one.getExecuteExistingDelayedTasksAfterShutdownPolicy());
812 <            assertFalse(one.getContinueExistingPeriodicTasksAfterShutdownPolicy());
810 >            e.invokeAny(new ArrayList<Callable<String>>());
811 >            shouldThrow();
812 >        } catch (IllegalArgumentException success) {
813 >        } finally {
814 >            joinPool(e);
815 >        }
816 >    }
817  
818 <            ScheduledCancellable[] tasks = new ScheduledCancellable[5];
819 <            for(int i = 0; i < 5; i++)
820 <                tasks[i] = one.schedule(new NoOpRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
821 <            one.shutdown();
822 <            BlockingQueue q = one.getQueue();
823 <            for (Iterator it = q.iterator(); it.hasNext();) {
824 <                ScheduledCancellable t = (ScheduledCancellable)it.next();
825 <                assertFalse(t.isCancelled());
826 <            }
827 <            assertTrue(one.isShutdown());
828 <            Thread.sleep(SMALL_DELAY_MS);
829 <            for (int i = 0; i < 5; ++i) {
830 <                assertTrue(tasks[i].isDone());
831 <                assertFalse(tasks[i].isCancelled());
832 <            }
833 <            
818 >    /**
819 >     * invokeAny(c) throws NPE if c has null elements
820 >     */
821 >    public void testInvokeAny3() throws Exception {
822 >        CountDownLatch latch = new CountDownLatch(1);
823 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
824 >        List<Callable<String>> l = new ArrayList<Callable<String>>();
825 >        l.add(latchAwaitingStringTask(latch));
826 >        l.add(null);
827 >        try {
828 >            e.invokeAny(l);
829 >            shouldThrow();
830 >        } catch (NullPointerException success) {
831 >        } finally {
832 >            latch.countDown();
833 >            joinPool(e);
834          }
835 <        catch(Exception ex) {
836 <            fail("unexpected exception");
835 >    }
836 >
837 >    /**
838 >     * invokeAny(c) throws ExecutionException if no task completes
839 >     */
840 >    public void testInvokeAny4() throws Exception {
841 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
842 >        List<Callable<String>> l = new ArrayList<Callable<String>>();
843 >        l.add(new NPETask());
844 >        try {
845 >            e.invokeAny(l);
846 >            shouldThrow();
847 >        } catch (ExecutionException success) {
848 >            assertTrue(success.getCause() instanceof NullPointerException);
849 >        } finally {
850 >            joinPool(e);
851          }
852      }
853  
854 +    /**
855 +     * invokeAny(c) returns result of some task
856 +     */
857 +    public void testInvokeAny5() throws Exception {
858 +        ExecutorService e = new ScheduledThreadPoolExecutor(2);
859 +        try {
860 +            List<Callable<String>> l = new ArrayList<Callable<String>>();
861 +            l.add(new StringTask());
862 +            l.add(new StringTask());
863 +            String result = e.invokeAny(l);
864 +            assertSame(TEST_STRING, result);
865 +        } finally {
866 +            joinPool(e);
867 +        }
868 +    }
869  
870 <    public void testShutDown2(){
870 >    /**
871 >     * invokeAll(null) throws NPE
872 >     */
873 >    public void testInvokeAll1() throws Exception {
874 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
875          try {
876 <            ScheduledExecutor one = new ScheduledExecutor(1);
877 <            one.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
878 <            ScheduledCancellable[] tasks = new ScheduledCancellable[5];
879 <            for(int i = 0; i < 5; i++)
880 <                tasks[i] = one.schedule(new NoOpRunnable(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
445 <            one.shutdown();
446 <            assertTrue(one.isShutdown());
447 <            BlockingQueue q = one.getQueue();
448 <            assertTrue(q.isEmpty());
449 <            Thread.sleep(SMALL_DELAY_MS);
450 <            assertTrue(one.isTerminated());
876 >            e.invokeAll(null);
877 >            shouldThrow();
878 >        } catch (NullPointerException success) {
879 >        } finally {
880 >            joinPool(e);
881          }
882 <        catch(Exception ex) {
883 <            fail("unexpected exception");
882 >    }
883 >
884 >    /**
885 >     * invokeAll(empty collection) returns empty collection
886 >     */
887 >    public void testInvokeAll2() throws Exception {
888 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
889 >        try {
890 >            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
891 >            assertTrue(r.isEmpty());
892 >        } finally {
893 >            joinPool(e);
894          }
895      }
896  
897 +    /**
898 +     * invokeAll(c) throws NPE if c has null elements
899 +     */
900 +    public void testInvokeAll3() throws Exception {
901 +        ExecutorService e = new ScheduledThreadPoolExecutor(2);
902 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
903 +        l.add(new StringTask());
904 +        l.add(null);
905 +        try {
906 +            e.invokeAll(l);
907 +            shouldThrow();
908 +        } catch (NullPointerException success) {
909 +        } finally {
910 +            joinPool(e);
911 +        }
912 +    }
913  
914 <    public void testShutDown3(){
914 >    /**
915 >     * get of invokeAll(c) throws exception on failed task
916 >     */
917 >    public void testInvokeAll4() throws Exception {
918 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
919 >        List<Callable<String>> l = new ArrayList<Callable<String>>();
920 >        l.add(new NPETask());
921 >        List<Future<String>> futures = e.invokeAll(l);
922 >        assertEquals(1, futures.size());
923          try {
924 <            ScheduledExecutor one = new ScheduledExecutor(1);
925 <            one.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
926 <            ScheduledCancellable task =
927 <                one.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, TimeUnit.MILLISECONDS);
928 <            one.shutdown();
929 <            assertTrue(one.isShutdown());
466 <            BlockingQueue q = one.getQueue();
467 <            assertTrue(q.isEmpty());
468 <            Thread.sleep(SHORT_DELAY_MS);
469 <            assertTrue(one.isTerminated());
924 >            futures.get(0).get();
925 >            shouldThrow();
926 >        } catch (ExecutionException success) {
927 >            assertTrue(success.getCause() instanceof NullPointerException);
928 >        } finally {
929 >            joinPool(e);
930          }
931 <        catch(Exception ex) {
932 <            fail("unexpected exception");
931 >    }
932 >
933 >    /**
934 >     * invokeAll(c) returns results of all completed tasks
935 >     */
936 >    public void testInvokeAll5() throws Exception {
937 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
938 >        try {
939 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
940 >            l.add(new StringTask());
941 >            l.add(new StringTask());
942 >            List<Future<String>> futures = e.invokeAll(l);
943 >            assertEquals(2, futures.size());
944 >            for (Future<String> future : futures)
945 >                assertSame(TEST_STRING, future.get());
946 >        } finally {
947 >            joinPool(e);
948          }
949      }
950  
951 <    public void testShutDown4(){
952 <        ScheduledExecutor one = new ScheduledExecutor(1);
951 >    /**
952 >     * timed invokeAny(null) throws NPE
953 >     */
954 >    public void testTimedInvokeAny1() throws Exception {
955 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
956          try {
957 <            one.setContinueExistingPeriodicTasksAfterShutdownPolicy(true);
958 <            ScheduledCancellable task =
959 <                one.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, TimeUnit.MILLISECONDS);
960 <            assertFalse(task.isCancelled());
961 <            one.shutdown();
484 <            assertFalse(task.isCancelled());
485 <            assertFalse(one.isTerminated());
486 <            assertTrue(one.isShutdown());
487 <            Thread.sleep(SHORT_DELAY_MS);
488 <            assertFalse(task.isCancelled());
489 <            task.cancel(true);
490 <            assertTrue(task.isCancelled());
491 <            Thread.sleep(SHORT_DELAY_MS);
492 <            assertTrue(one.isTerminated());
957 >            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
958 >            shouldThrow();
959 >        } catch (NullPointerException success) {
960 >        } finally {
961 >            joinPool(e);
962          }
963 <        catch(Exception ex) {
964 <            fail("unexpected exception");
963 >    }
964 >
965 >    /**
966 >     * timed invokeAny(,,null) throws NPE
967 >     */
968 >    public void testTimedInvokeAnyNullTimeUnit() throws Exception {
969 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
970 >        List<Callable<String>> l = new ArrayList<Callable<String>>();
971 >        l.add(new StringTask());
972 >        try {
973 >            e.invokeAny(l, MEDIUM_DELAY_MS, null);
974 >            shouldThrow();
975 >        } catch (NullPointerException success) {
976 >        } finally {
977 >            joinPool(e);
978          }
979 <        finally {
980 <            one.shutdownNow();
979 >    }
980 >
981 >    /**
982 >     * timed invokeAny(empty collection) throws IAE
983 >     */
984 >    public void testTimedInvokeAny2() throws Exception {
985 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
986 >        try {
987 >            e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
988 >            shouldThrow();
989 >        } catch (IllegalArgumentException success) {
990 >        } finally {
991 >            joinPool(e);
992 >        }
993 >    }
994 >
995 >    /**
996 >     * timed invokeAny(c) throws NPE if c has null elements
997 >     */
998 >    public void testTimedInvokeAny3() throws Exception {
999 >        CountDownLatch latch = new CountDownLatch(1);
1000 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
1001 >        List<Callable<String>> l = new ArrayList<Callable<String>>();
1002 >        l.add(latchAwaitingStringTask(latch));
1003 >        l.add(null);
1004 >        try {
1005 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1006 >            shouldThrow();
1007 >        } catch (NullPointerException success) {
1008 >        } finally {
1009 >            latch.countDown();
1010 >            joinPool(e);
1011 >        }
1012 >    }
1013 >
1014 >    /**
1015 >     * timed invokeAny(c) throws ExecutionException if no task completes
1016 >     */
1017 >    public void testTimedInvokeAny4() throws Exception {
1018 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
1019 >        List<Callable<String>> l = new ArrayList<Callable<String>>();
1020 >        l.add(new NPETask());
1021 >        try {
1022 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1023 >            shouldThrow();
1024 >        } catch (ExecutionException success) {
1025 >            assertTrue(success.getCause() instanceof NullPointerException);
1026 >        } finally {
1027 >            joinPool(e);
1028 >        }
1029 >    }
1030 >
1031 >    /**
1032 >     * timed invokeAny(c) returns result of some task
1033 >     */
1034 >    public void testTimedInvokeAny5() throws Exception {
1035 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
1036 >        try {
1037 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
1038 >            l.add(new StringTask());
1039 >            l.add(new StringTask());
1040 >            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1041 >            assertSame(TEST_STRING, result);
1042 >        } finally {
1043 >            joinPool(e);
1044 >        }
1045 >    }
1046 >
1047 >    /**
1048 >     * timed invokeAll(null) throws NPE
1049 >     */
1050 >    public void testTimedInvokeAll1() throws Exception {
1051 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
1052 >        try {
1053 >            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1054 >            shouldThrow();
1055 >        } catch (NullPointerException success) {
1056 >        } finally {
1057 >            joinPool(e);
1058 >        }
1059 >    }
1060 >
1061 >    /**
1062 >     * timed invokeAll(,,null) throws NPE
1063 >     */
1064 >    public void testTimedInvokeAllNullTimeUnit() throws Exception {
1065 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
1066 >        List<Callable<String>> l = new ArrayList<Callable<String>>();
1067 >        l.add(new StringTask());
1068 >        try {
1069 >            e.invokeAll(l, MEDIUM_DELAY_MS, null);
1070 >            shouldThrow();
1071 >        } catch (NullPointerException success) {
1072 >        } finally {
1073 >            joinPool(e);
1074 >        }
1075 >    }
1076 >
1077 >    /**
1078 >     * timed invokeAll(empty collection) returns empty collection
1079 >     */
1080 >    public void testTimedInvokeAll2() throws Exception {
1081 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
1082 >        try {
1083 >            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1084 >            assertTrue(r.isEmpty());
1085 >        } finally {
1086 >            joinPool(e);
1087 >        }
1088 >    }
1089 >
1090 >    /**
1091 >     * timed invokeAll(c) throws NPE if c has null elements
1092 >     */
1093 >    public void testTimedInvokeAll3() throws Exception {
1094 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
1095 >        List<Callable<String>> l = new ArrayList<Callable<String>>();
1096 >        l.add(new StringTask());
1097 >        l.add(null);
1098 >        try {
1099 >            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1100 >            shouldThrow();
1101 >        } catch (NullPointerException success) {
1102 >        } finally {
1103 >            joinPool(e);
1104 >        }
1105 >    }
1106 >
1107 >    /**
1108 >     * get of element of invokeAll(c) throws exception on failed task
1109 >     */
1110 >    public void testTimedInvokeAll4() throws Exception {
1111 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
1112 >        List<Callable<String>> l = new ArrayList<Callable<String>>();
1113 >        l.add(new NPETask());
1114 >        List<Future<String>> futures =
1115 >            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1116 >        assertEquals(1, futures.size());
1117 >        try {
1118 >            futures.get(0).get();
1119 >            shouldThrow();
1120 >        } catch (ExecutionException success) {
1121 >            assertTrue(success.getCause() instanceof NullPointerException);
1122 >        } finally {
1123 >            joinPool(e);
1124 >        }
1125 >    }
1126 >
1127 >    /**
1128 >     * timed invokeAll(c) returns results of all completed tasks
1129 >     */
1130 >    public void testTimedInvokeAll5() throws Exception {
1131 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
1132 >        try {
1133 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
1134 >            l.add(new StringTask());
1135 >            l.add(new StringTask());
1136 >            List<Future<String>> futures =
1137 >                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1138 >            assertEquals(2, futures.size());
1139 >            for (Future<String> future : futures)
1140 >                assertSame(TEST_STRING, future.get());
1141 >        } finally {
1142 >            joinPool(e);
1143 >        }
1144 >    }
1145 >
1146 >    /**
1147 >     * timed invokeAll(c) cancels tasks not completed by timeout
1148 >     */
1149 >    public void testTimedInvokeAll6() throws Exception {
1150 >        ExecutorService e = new ScheduledThreadPoolExecutor(2);
1151 >        try {
1152 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
1153 >            l.add(new StringTask());
1154 >            l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1155 >            l.add(new StringTask());
1156 >            List<Future<String>> futures =
1157 >                e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1158 >            assertEquals(3, futures.size());
1159 >            Iterator<Future<String>> it = futures.iterator();
1160 >            Future<String> f1 = it.next();
1161 >            Future<String> f2 = it.next();
1162 >            Future<String> f3 = it.next();
1163 >            assertTrue(f1.isDone());
1164 >            assertTrue(f2.isDone());
1165 >            assertTrue(f3.isDone());
1166 >            assertFalse(f1.isCancelled());
1167 >            assertTrue(f2.isCancelled());
1168 >        } finally {
1169 >            joinPool(e);
1170          }
1171      }
1172  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines