ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ScheduledExecutorTest.java

Comparing jsr166/src/test/tck/ScheduledExecutorTest.java (file contents):
Revision 1.27 by jsr166, Sat Nov 21 17:38:05 2009 UTC vs.
Revision 1.34 by jsr166, Mon Oct 11 15:46:40 2010 UTC

#	Line 14 | Line 14 | 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);
#	Line 25 | Line 25 | public class ScheduledExecutorTest exten
25		* execute successfully executes a runnable
26		*/
27		public void testExecute() throws InterruptedException {
28	<	TrackedShortRunnable runnable =new TrackedShortRunnable();
29	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
30	<	p1.execute(runnable);
31	<	assertFalse(runnable.done);
32	<	Thread.sleep(SHORT_DELAY_MS);
33	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
34	<	Thread.sleep(MEDIUM_DELAY_MS);
35	<	assertTrue(runnable.done);
36	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
37	<	joinPool(p1);
28	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
29	>	final CountDownLatch done = new CountDownLatch(1);
30	>	final Runnable task = new CheckedRunnable() {
31	>	public void realRun() {
32	>	done.countDown();
33	>	}};
34	>	try {
35	>	p.execute(task);
36	>	assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
37	>	} finally {
38	>	joinPool(p);
39	>	}
40		}
41
42
#	Line 42 | Line 44 | public class ScheduledExecutorTest exten
44		* delayed schedule of callable successfully executes after delay
45		*/
46		public void testSchedule1() throws Exception {
47	<	TrackedCallable callable = new TrackedCallable();
48	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
49	<	Future f = p1.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
50	<	assertFalse(callable.done);
51	<	Thread.sleep(MEDIUM_DELAY_MS);
52	<	assertTrue(callable.done);
53	<	assertEquals(Boolean.TRUE, f.get());
54	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
55	<	joinPool(p1);
47	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
48	>	final long t0 = System.nanoTime();
49	>	final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
50	>	final CountDownLatch done = new CountDownLatch(1);
51	>	try {
52	>	Callable task = new CheckedCallable<Boolean>() {
53	>	public Boolean realCall() {
54	>	done.countDown();
55	>	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
56	>	return Boolean.TRUE;
57	>	}};
58	>	Future f = p.schedule(task, SHORT_DELAY_MS, MILLISECONDS);
59	>	assertEquals(Boolean.TRUE, f.get());
60	>	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
61	>	assertTrue(done.await(0L, MILLISECONDS));
62	>	} finally {
63	>	joinPool(p);
64	>	}
65		}
66
67		/**
68	<	*  delayed schedule of runnable successfully executes after delay
69	<	*/
70	<	public void testSchedule3() throws InterruptedException {
71	<	TrackedShortRunnable runnable = new TrackedShortRunnable();
72	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
73	<	p1.schedule(runnable, SMALL_DELAY_MS, MILLISECONDS);
74	<	Thread.sleep(SHORT_DELAY_MS);
75	<	assertFalse(runnable.done);
76	<	Thread.sleep(MEDIUM_DELAY_MS);
77	<	assertTrue(runnable.done);
78	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
79	<	joinPool(p1);
68	>	* delayed schedule of runnable successfully executes after delay
69	>	*/
70	>	public void testSchedule3() throws Exception {
71	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
72	>	final long t0 = System.nanoTime();
73	>	final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
74	>	final CountDownLatch done = new CountDownLatch(1);
75	>	try {
76	>	Runnable task = new CheckedRunnable() {
77	>	public void realRun() {
78	>	done.countDown();
79	>	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
80	>	}};
81	>	Future f = p.schedule(task, SHORT_DELAY_MS, MILLISECONDS);
82	>	assertNull(f.get());
83	>	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
84	>	assertTrue(done.await(0L, MILLISECONDS));
85	>	} finally {
86	>	joinPool(p);
87	>	}
88		}
89
90		/**
91		* scheduleAtFixedRate executes runnable after given initial delay
92		*/
93	<	public void testSchedule4() throws InterruptedException {
94	<	TrackedShortRunnable runnable = new TrackedShortRunnable();
95	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
96	<	ScheduledFuture h = p1.scheduleAtFixedRate(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, MILLISECONDS);
97	<	assertFalse(runnable.done);
98	<	Thread.sleep(MEDIUM_DELAY_MS);
99	<	assertTrue(runnable.done);
100	<	h.cancel(true);
101	<	joinPool(p1);
102	<	}
103	<
104	<	static class RunnableCounter implements Runnable {
105	<	AtomicInteger count = new AtomicInteger(0);
106	<	public void run() { count.getAndIncrement(); }
93	>	public void testSchedule4() throws Exception {
94	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
95	>	final long t0 = System.nanoTime();
96	>	final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
97	>	final CountDownLatch done = new CountDownLatch(1);
98	>	try {
99	>	Runnable task = new CheckedRunnable() {
100	>	public void realRun() {
101	>	done.countDown();
102	>	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
103	>	}};
104	>	ScheduledFuture f =
105	>	p.scheduleAtFixedRate(task, SHORT_DELAY_MS,
106	>	SHORT_DELAY_MS, MILLISECONDS);
107	>	assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
108	>	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
109	>	f.cancel(true);
110	>	} finally {
111	>	joinPool(p);
112	>	}
113		}
114
115		/**
116		* scheduleWithFixedDelay executes runnable after given initial delay
117		*/
118		public void testSchedule5() throws InterruptedException {
119	<	TrackedShortRunnable runnable = new TrackedShortRunnable();
120	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
121	<	ScheduledFuture h = p1.scheduleWithFixedDelay(runnable, SHORT_DELAY_MS, SHORT_DELAY_MS, MILLISECONDS);
122	<	assertFalse(runnable.done);
123	<	Thread.sleep(MEDIUM_DELAY_MS);
124	<	assertTrue(runnable.done);
125	<	h.cancel(true);
126	<	joinPool(p1);
119	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
120	>	final long t0 = System.nanoTime();
121	>	final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
122	>	final CountDownLatch done = new CountDownLatch(1);
123	>	try {
124	>	Runnable task = new CheckedRunnable() {
125	>	public void realRun() {
126	>	done.countDown();
127	>	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
128	>	}};
129	>	ScheduledFuture f =
130	>	p.scheduleWithFixedDelay(task, SHORT_DELAY_MS,
131	>	SHORT_DELAY_MS, MILLISECONDS);
132	>	assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
133	>	assertTrue(System.nanoTime() - t0 >= timeoutNanos);
134	>	f.cancel(true);
135	>	} finally {
136	>	joinPool(p);
137	>	}
138	>	}
139	>
140	>	static class RunnableCounter implements Runnable {
141	>	AtomicInteger count = new AtomicInteger(0);
142	>	public void run() { count.getAndIncrement(); }
143		}
144
145		/**
146		* scheduleAtFixedRate executes series of tasks at given rate
147		*/
148		public void testFixedRateSequence() throws InterruptedException {
149	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
149	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
150		RunnableCounter counter = new RunnableCounter();
151		ScheduledFuture h =
152	<	p1.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS);
152	>	p.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS);
153		Thread.sleep(SMALL_DELAY_MS);
154		h.cancel(true);
155		int c = counter.count.get();
#	Line 116 | Line 157 | public class ScheduledExecutorTest exten
157		// an execution per SHORT delay, but no more than one SHORT more
158		assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
159		assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
160	<	joinPool(p1);
160	>	joinPool(p);
161		}
162
163		/**
164		* scheduleWithFixedDelay executes series of tasks with given period
165		*/
166		public void testFixedDelaySequence() throws InterruptedException {
167	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
167	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
168		RunnableCounter counter = new RunnableCounter();
169		ScheduledFuture h =
170	<	p1.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS);
170	>	p.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS);
171		Thread.sleep(SMALL_DELAY_MS);
172		h.cancel(true);
173		int c = counter.count.get();
174		assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
175		assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
176	<	joinPool(p1);
176	>	joinPool(p);
177		}
178
179
180		/**
181	<	*  execute (null) throws NPE
181	>	* execute(null) throws NPE
182		*/
183		public void testExecuteNull() throws InterruptedException {
184		ScheduledThreadPoolExecutor se = null;
#	Line 151 | Line 192 | public class ScheduledExecutorTest exten
192		}
193
194		/**
195	<	* schedule (null) throws NPE
195	>	* schedule(null) throws NPE
196		*/
197		public void testScheduleNull() throws InterruptedException {
198		ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
#	Line 178 | Line 219 | public class ScheduledExecutorTest exten
219		}
220
221		joinPool(se);
181	–
222		}
223
224		/**
#	Line 214 | Line 254 | public class ScheduledExecutorTest exten
254		}
255
256		/**
257	<	*  scheduleAtFixedRate throws RejectedExecutionException if shutdown
257	>	* scheduleAtFixedRate throws RejectedExecutionException if shutdown
258		*/
259		public void testScheduleAtFixedRate1_RejectedExecutionException() throws InterruptedException {
260		ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
#	Line 246 | Line 286 | public class ScheduledExecutorTest exten
286		}
287
288		/**
289	<	*  getActiveCount increases but doesn't overestimate, when a
290	<	*  thread becomes active
289	>	* getActiveCount increases but doesn't overestimate, when a
290	>	* thread becomes active
291		*/
292		public void testGetActiveCount() throws InterruptedException {
293	<	ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2);
294	<	assertEquals(0, p2.getActiveCount());
295	<	p2.execute(new SmallRunnable());
296	<	Thread.sleep(SHORT_DELAY_MS);
297	<	assertEquals(1, p2.getActiveCount());
298	<	joinPool(p2);
293	>	final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(2);
294	>	final CountDownLatch threadStarted = new CountDownLatch(1);
295	>	final CountDownLatch done = new CountDownLatch(1);
296	>	try {
297	>	assertEquals(0, p.getActiveCount());
298	>	p.execute(new CheckedRunnable() {
299	>	public void realRun() throws InterruptedException {
300	>	threadStarted.countDown();
301	>	assertEquals(1, p.getActiveCount());
302	>	done.await();
303	>	}});
304	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
305	>	assertEquals(1, p.getActiveCount());
306	>	} finally {
307	>	done.countDown();
308	>	joinPool(p);
309	>	}
310		}
311
312		/**
313	<	*    getCompletedTaskCount increases, but doesn't overestimate,
314	<	*   when tasks complete
313	>	* getCompletedTaskCount increases, but doesn't overestimate,
314	>	* when tasks complete
315		*/
316		public void testGetCompletedTaskCount() throws InterruptedException {
317	<	ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2);
318	<	assertEquals(0, p2.getCompletedTaskCount());
319	<	p2.execute(new SmallRunnable());
320	<	Thread.sleep(MEDIUM_DELAY_MS);
321	<	assertEquals(1, p2.getCompletedTaskCount());
322	<	joinPool(p2);
317	>	final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(2);
318	>	final CountDownLatch threadStarted = new CountDownLatch(1);
319	>	final CountDownLatch threadProceed = new CountDownLatch(1);
320	>	final CountDownLatch threadDone = new CountDownLatch(1);
321	>	try {
322	>	assertEquals(0, p.getCompletedTaskCount());
323	>	p.execute(new CheckedRunnable() {
324	>	public void realRun() throws InterruptedException {
325	>	threadStarted.countDown();
326	>	assertEquals(0, p.getCompletedTaskCount());
327	>	threadProceed.await();
328	>	threadDone.countDown();
329	>	}});
330	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
331	>	assertEquals(0, p.getCompletedTaskCount());
332	>	threadProceed.countDown();
333	>	threadDone.await();
334	>	Thread.sleep(SHORT_DELAY_MS);
335	>	assertEquals(1, p.getCompletedTaskCount());
336	>	} finally {
337	>	joinPool(p);
338	>	}
339		}
340
341		/**
342	<	*  getCorePoolSize returns size given in constructor if not otherwise set
342	>	* getCorePoolSize returns size given in constructor if not otherwise set
343		*/
344		public void testGetCorePoolSize() throws InterruptedException {
345	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
346	<	assertEquals(1, p1.getCorePoolSize());
347	<	joinPool(p1);
345	>	ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
346	>	assertEquals(1, p.getCorePoolSize());
347	>	joinPool(p);
348		}
349
350		/**
351	<	*    getLargestPoolSize increases, but doesn't overestimate, when
352	<	*   multiple threads active
351	>	* getLargestPoolSize increases, but doesn't overestimate, when
352	>	* multiple threads active
353		*/
354		public void testGetLargestPoolSize() throws InterruptedException {
355	<	ScheduledThreadPoolExecutor p2 = new ScheduledThreadPoolExecutor(2);
356	<	assertEquals(0, p2.getLargestPoolSize());
357	<	p2.execute(new SmallRunnable());
358	<	p2.execute(new SmallRunnable());
359	<	Thread.sleep(SHORT_DELAY_MS);
360	<	assertEquals(2, p2.getLargestPoolSize());
361	<	joinPool(p2);
355	>	final int THREADS = 3;
356	>	final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(THREADS);
357	>	final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
358	>	final CountDownLatch done = new CountDownLatch(1);
359	>	try {
360	>	assertEquals(0, p.getLargestPoolSize());
361	>	for (int i = 0; i < THREADS; i++)
362	>	p.execute(new CheckedRunnable() {
363	>	public void realRun() throws InterruptedException {
364	>	threadsStarted.countDown();
365	>	done.await();
366	>	assertEquals(THREADS, p.getLargestPoolSize());
367	>	}});
368	>	assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS));
369	>	assertEquals(THREADS, p.getLargestPoolSize());
370	>	} finally {
371	>	done.countDown();
372	>	joinPool(p);
373	>	assertEquals(THREADS, p.getLargestPoolSize());
374	>	}
375		}
376
377		/**
378	<	*   getPoolSize increases, but doesn't overestimate, when threads
379	<	*   become active
378	>	* getPoolSize increases, but doesn't overestimate, when threads
379	>	* become active
380		*/
381		public void testGetPoolSize() throws InterruptedException {
382	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
383	<	assertEquals(0, p1.getPoolSize());
384	<	p1.execute(new SmallRunnable());
385	<	assertEquals(1, p1.getPoolSize());
386	<	joinPool(p1);
382	>	final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
383	>	final CountDownLatch threadStarted = new CountDownLatch(1);
384	>	final CountDownLatch done = new CountDownLatch(1);
385	>	try {
386	>	assertEquals(0, p.getPoolSize());
387	>	p.execute(new CheckedRunnable() {
388	>	public void realRun() throws InterruptedException {
389	>	threadStarted.countDown();
390	>	assertEquals(1, p.getPoolSize());
391	>	done.await();
392	>	}});
393	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
394	>	assertEquals(1, p.getPoolSize());
395	>	} finally {
396	>	done.countDown();
397	>	joinPool(p);
398	>	}
399		}
400
401		/**
402	<	*    getTaskCount increases, but doesn't overestimate, when tasks
403	<	*    submitted
402	>	* getTaskCount increases, but doesn't overestimate, when tasks
403	>	* submitted
404		*/
405		public void testGetTaskCount() throws InterruptedException {
406	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
407	<	assertEquals(0, p1.getTaskCount());
408	<	for (int i = 0; i < 5; i++)
409	<	p1.execute(new SmallRunnable());
410	<	Thread.sleep(SHORT_DELAY_MS);
411	<	assertEquals(5, p1.getTaskCount());
412	<	joinPool(p1);
406	>	final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
407	>	final CountDownLatch threadStarted = new CountDownLatch(1);
408	>	final CountDownLatch done = new CountDownLatch(1);
409	>	final int TASKS = 5;
410	>	try {
411	>	assertEquals(0, p.getTaskCount());
412	>	for (int i = 0; i < TASKS; i++)
413	>	p.execute(new CheckedRunnable() {
414	>	public void realRun() throws InterruptedException {
415	>	threadStarted.countDown();
416	>	done.await();
417	>	}});
418	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
419	>	assertEquals(TASKS, p.getTaskCount());
420	>	} finally {
421	>	done.countDown();
422	>	joinPool(p);
423	>	}
424		}
425
426		/**
#	Line 356 | Line 459 | public class ScheduledExecutorTest exten
459		}
460
461		/**
462	<	*   is isShutDown is false before shutdown, true after
462	>	* isShutDown is false before shutdown, true after
463		*/
464		public void testIsShutdown() {
465
466	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
466	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
467		try {
468	<	assertFalse(p1.isShutdown());
468	>	assertFalse(p.isShutdown());
469		}
470		finally {
471	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
471	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
472		}
473	<	assertTrue(p1.isShutdown());
473	>	assertTrue(p.isShutdown());
474		}
475
476
477		/**
478	<	*   isTerminated is false before termination, true after
478	>	* isTerminated is false before termination, true after
479		*/
480		public void testIsTerminated() throws InterruptedException {
481	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
481	>	final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
482	>	final CountDownLatch threadStarted = new CountDownLatch(1);
483	>	final CountDownLatch done = new CountDownLatch(1);
484	>	assertFalse(p.isTerminated());
485		try {
486	<	p1.execute(new SmallRunnable());
486	>	p.execute(new CheckedRunnable() {
487	>	public void realRun() throws InterruptedException {
488	>	threadStarted.countDown();
489	>	assertFalse(p.isTerminated());
490	>	done.await();
491	>	}});
492	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
493	>	done.countDown();
494		} finally {
495	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
495	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
496		}
497	<	assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
498	<	assertTrue(p1.isTerminated());
497	>	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
498	>	assertTrue(p.isTerminated());
499		}
500
501		/**
502	<	*  isTerminating is not true when running or when terminated
502	>	* isTerminating is not true when running or when terminated
503		*/
504		public void testIsTerminating() throws InterruptedException {
505	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
506	<	assertFalse(p1.isTerminating());
507	<	try {
508	<	p1.execute(new SmallRunnable());
509	<	assertFalse(p1.isTerminating());
510	<	} finally {
511	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
512	<	}
513	<
514	<	assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
515	<	assertTrue(p1.isTerminated());
516	<	assertFalse(p1.isTerminating());
505	>	final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
506	>	final CountDownLatch threadStarted = new CountDownLatch(1);
507	>	final CountDownLatch done = new CountDownLatch(1);
508	>	try {
509	>	assertFalse(p.isTerminating());
510	>	p.execute(new CheckedRunnable() {
511	>	public void realRun() throws InterruptedException {
512	>	threadStarted.countDown();
513	>	assertFalse(p.isTerminating());
514	>	done.await();
515	>	}});
516	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
517	>	assertFalse(p.isTerminating());
518	>	done.countDown();
519	>	} finally {
520	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
521	>	}
522	>	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
523	>	assertTrue(p.isTerminated());
524	>	assertFalse(p.isTerminating());
525		}
526
527		/**
528		* getQueue returns the work queue, which contains queued tasks
529		*/
530		public void testGetQueue() throws InterruptedException {
531	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
532	<	ScheduledFuture[] tasks = new ScheduledFuture[5];
533	<	for (int i = 0; i < 5; i++) {
413	<	tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, MILLISECONDS);
414	<	}
531	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
532	>	final CountDownLatch threadStarted = new CountDownLatch(1);
533	>	final CountDownLatch done = new CountDownLatch(1);
534		try {
535	<	Thread.sleep(SHORT_DELAY_MS);
536	<	BlockingQueue<Runnable> q = p1.getQueue();
537	<	assertTrue(q.contains(tasks[4]));
535	>	ScheduledFuture[] tasks = new ScheduledFuture[5];
536	>	for (int i = 0; i < tasks.length; i++) {
537	>	Runnable r = new CheckedRunnable() {
538	>	public void realRun() throws InterruptedException {
539	>	threadStarted.countDown();
540	>	done.await();
541	>	}};
542	>	tasks[i] = p.schedule(r, 1, MILLISECONDS);
543	>	}
544	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
545	>	BlockingQueue<Runnable> q = p.getQueue();
546	>	assertTrue(q.contains(tasks[tasks.length - 1]));
547		assertFalse(q.contains(tasks[0]));
548		} finally {
549	<	joinPool(p1);
549	>	done.countDown();
550	>	joinPool(p);
551		}
552		}
553
#	Line 426 | Line 555 | public class ScheduledExecutorTest exten
555		* remove(task) removes queued task, and fails to remove active task
556		*/
557		public void testRemove() throws InterruptedException {
558	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
558	>	final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
559		ScheduledFuture[] tasks = new ScheduledFuture[5];
560	<	for (int i = 0; i < 5; i++) {
561	<	tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), 1, MILLISECONDS);
433	<	}
560	>	final CountDownLatch threadStarted = new CountDownLatch(1);
561	>	final CountDownLatch done = new CountDownLatch(1);
562		try {
563	<	Thread.sleep(SHORT_DELAY_MS);
564	<	BlockingQueue<Runnable> q = p1.getQueue();
565	<	assertFalse(p1.remove((Runnable)tasks[0]));
563	>	for (int i = 0; i < tasks.length; i++) {
564	>	Runnable r = new CheckedRunnable() {
565	>	public void realRun() throws InterruptedException {
566	>	threadStarted.countDown();
567	>	done.await();
568	>	}};
569	>	tasks[i] = p.schedule(r, 1, MILLISECONDS);
570	>	}
571	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
572	>	BlockingQueue<Runnable> q = p.getQueue();
573	>	assertFalse(p.remove((Runnable)tasks[0]));
574		assertTrue(q.contains((Runnable)tasks[4]));
575		assertTrue(q.contains((Runnable)tasks[3]));
576	<	assertTrue(p1.remove((Runnable)tasks[4]));
577	<	assertFalse(p1.remove((Runnable)tasks[4]));
576	>	assertTrue(p.remove((Runnable)tasks[4]));
577	>	assertFalse(p.remove((Runnable)tasks[4]));
578		assertFalse(q.contains((Runnable)tasks[4]));
579		assertTrue(q.contains((Runnable)tasks[3]));
580	<	assertTrue(p1.remove((Runnable)tasks[3]));
580	>	assertTrue(p.remove((Runnable)tasks[3]));
581		assertFalse(q.contains((Runnable)tasks[3]));
582		} finally {
583	<	joinPool(p1);
583	>	done.countDown();
584	>	joinPool(p);
585		}
586		}
587
588		/**
589	<	*  purge removes cancelled tasks from the queue
589	>	* purge removes cancelled tasks from the queue
590		*/
591		public void testPurge() throws InterruptedException {
592	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
592	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
593		ScheduledFuture[] tasks = new ScheduledFuture[5];
594	<	for (int i = 0; i < 5; i++) {
595	<	tasks[i] = p1.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
594	>	for (int i = 0; i < tasks.length; i++) {
595	>	tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
596		}
597		try {
598	<	int max = 5;
598	>	int max = tasks.length;
599		if (tasks[4].cancel(true)) --max;
600		if (tasks[3].cancel(true)) --max;
601		// There must eventually be an interference-free point at
602		// which purge will not fail. (At worst, when queue is empty.)
603		int k;
604		for (k = 0; k < SMALL_DELAY_MS; ++k) {
605	<	p1.purge();
606	<	long count = p1.getTaskCount();
605	>	p.purge();
606	>	long count = p.getTaskCount();
607		if (count >= 0 && count <= max)
608		break;
609		Thread.sleep(1);
610		}
611		assertTrue(k < SMALL_DELAY_MS);
612		} finally {
613	<	joinPool(p1);
613	>	for (ScheduledFuture task : tasks)
614	>	task.cancel(true);
615	>	joinPool(p);
616		}
617		}
618
619		/**
620	<	*  shutDownNow returns a list containing tasks that were not run
620	>	* shutDownNow returns a list containing tasks that were not run
621		*/
622		public void testShutDownNow() throws InterruptedException {
623	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
623	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
624		for (int i = 0; i < 5; i++)
625	<	p1.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
625	>	p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
626		List l;
627		try {
628	<	l = p1.shutdownNow();
628	>	l = p.shutdownNow();
629		} catch (SecurityException ok) {
630		return;
631		}
632	<	assertTrue(p1.isShutdown());
632	>	assertTrue(p.isShutdown());
633		assertTrue(l.size() > 0 && l.size() <= 5);
634	<	joinPool(p1);
634	>	joinPool(p);
635		}
636
637		/**
#	Line 500 | Line 639 | public class ScheduledExecutorTest exten
639		* tasks at shutdown
640		*/
641		public void testShutDown1() throws InterruptedException {
642	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
643	<	assertTrue(p1.getExecuteExistingDelayedTasksAfterShutdownPolicy());
644	<	assertFalse(p1.getContinueExistingPeriodicTasksAfterShutdownPolicy());
642	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
643	>	assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
644	>	assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
645
646		ScheduledFuture[] tasks = new ScheduledFuture[5];
647	<	for (int i = 0; i < 5; i++)
648	<	tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, MILLISECONDS);
649	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
650	<	BlockingQueue q = p1.getQueue();
651	<	for (Iterator it = q.iterator(); it.hasNext();) {
652	<	ScheduledFuture t = (ScheduledFuture)it.next();
653	<	assertFalse(t.isCancelled());
647	>	for (int i = 0; i < tasks.length; i++)
648	>	tasks[i] = p.schedule(new NoOpRunnable(),
649	>	SHORT_DELAY_MS, MILLISECONDS);
650	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
651	>	BlockingQueue<Runnable> q = p.getQueue();
652	>	for (ScheduledFuture task : tasks) {
653	>	assertFalse(task.isDone());
654	>	assertFalse(task.isCancelled());
655	>	assertTrue(q.contains(task));
656		}
657	<	assertTrue(p1.isShutdown());
658	<	Thread.sleep(SMALL_DELAY_MS);
659	<	for (int i = 0; i < 5; ++i) {
660	<	assertTrue(tasks[i].isDone());
661	<	assertFalse(tasks[i].isCancelled());
657	>	assertTrue(p.isShutdown());
658	>	assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
659	>	assertTrue(p.isTerminated());
660	>	for (ScheduledFuture task : tasks) {
661	>	assertTrue(task.isDone());
662	>	assertFalse(task.isCancelled());
663		}
664		}
665
#	Line 527 | Line 669 | public class ScheduledExecutorTest exten
669		* delayed tasks are cancelled at shutdown
670		*/
671		public void testShutDown2() throws InterruptedException {
672	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
673	<	p1.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
672	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
673	>	p.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
674	>	assertFalse(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
675	>	assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
676		ScheduledFuture[] tasks = new ScheduledFuture[5];
677	<	for (int i = 0; i < 5; i++)
678	<	tasks[i] = p1.schedule(new NoOpRunnable(), SHORT_DELAY_MS, MILLISECONDS);
679	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
680	<	assertTrue(p1.isShutdown());
681	<	BlockingQueue q = p1.getQueue();
677	>	for (int i = 0; i < tasks.length; i++)
678	>	tasks[i] = p.schedule(new NoOpRunnable(),
679	>	SHORT_DELAY_MS, MILLISECONDS);
680	>	BlockingQueue q = p.getQueue();
681	>	assertEquals(tasks.length, q.size());
682	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
683	>	assertTrue(p.isShutdown());
684		assertTrue(q.isEmpty());
685	<	Thread.sleep(SMALL_DELAY_MS);
686	<	assertTrue(p1.isTerminated());
685	>	assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
686	>	assertTrue(p.isTerminated());
687	>	for (ScheduledFuture task : tasks) {
688	>	assertTrue(task.isDone());
689	>	assertTrue(task.isCancelled());
690	>	}
691		}
692
543	–
693		/**
694		* If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
695	<	* periodic tasks are not cancelled at shutdown
695	>	* periodic tasks are cancelled at shutdown
696		*/
697		public void testShutDown3() throws InterruptedException {
698	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
699	<	p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
698	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
699	>	assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
700	>	assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
701	>	p.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
702	>	assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
703	>	assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
704		ScheduledFuture task =
705	<	p1.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, MILLISECONDS);
706	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
707	<	assertTrue(p1.isShutdown());
708	<	BlockingQueue q = p1.getQueue();
709	<	assertTrue(q.isEmpty());
710	<	Thread.sleep(SHORT_DELAY_MS);
711	<	assertTrue(p1.isTerminated());
705	>	p.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, MILLISECONDS);
706	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
707	>	assertTrue(p.isShutdown());
708	>	BlockingQueue q = p.getQueue();
709	>	assertTrue(p.getQueue().isEmpty());
710	>	assertTrue(task.isDone());
711	>	assertTrue(task.isCancelled());
712	>	assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
713	>	assertTrue(p.isTerminated());
714		}
715
716		/**
717		* if setContinueExistingPeriodicTasksAfterShutdownPolicy is true,
718	<	* periodic tasks are cancelled at shutdown
718	>	* periodic tasks are not cancelled at shutdown
719		*/
720		public void testShutDown4() throws InterruptedException {
721	<	ScheduledThreadPoolExecutor p1 = new ScheduledThreadPoolExecutor(1);
721	>	ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
722	>	final CountDownLatch counter = new CountDownLatch(2);
723		try {
724	<	p1.setContinueExistingPeriodicTasksAfterShutdownPolicy(true);
724	>	p.setContinueExistingPeriodicTasksAfterShutdownPolicy(true);
725	>	assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
726	>	assertTrue(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
727	>	final Runnable r = new CheckedRunnable() {
728	>	public void realRun() {
729	>	counter.countDown();
730	>	}};
731		ScheduledFuture task =
732	<	p1.scheduleAtFixedRate(new NoOpRunnable(), 1, 1, MILLISECONDS);
732	>	p.scheduleAtFixedRate(r, 1, 1, MILLISECONDS);
733	>	assertFalse(task.isDone());
734		assertFalse(task.isCancelled());
735	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
735	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
736		assertFalse(task.isCancelled());
737	<	assertFalse(p1.isTerminated());
738	<	assertTrue(p1.isShutdown());
739	<	Thread.sleep(SHORT_DELAY_MS);
737	>	assertFalse(p.isTerminated());
738	>	assertTrue(p.isShutdown());
739	>	assertTrue(counter.await(SMALL_DELAY_MS, MILLISECONDS));
740		assertFalse(task.isCancelled());
741	<	assertTrue(task.cancel(true));
741	>	assertTrue(task.cancel(false));
742		assertTrue(task.isDone());
743	<	Thread.sleep(SHORT_DELAY_MS);
744	<	assertTrue(p1.isTerminated());
743	>	assertTrue(task.isCancelled());
744	>	assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
745	>	assertTrue(p.isTerminated());
746		}
747		finally {
748	<	joinPool(p1);
748	>	joinPool(p);
749		}
750		}
751
#	Line 659 | Line 823 | public class ScheduledExecutorTest exten
823		* invokeAny(c) throws NPE if c has null elements
824		*/
825		public void testInvokeAny3() throws Exception {
826	<	final CountDownLatch latch = new CountDownLatch(1);
826	>	CountDownLatch latch = new CountDownLatch(1);
827		ExecutorService e = new ScheduledThreadPoolExecutor(2);
828	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
829	+	l.add(latchAwaitingStringTask(latch));
830	+	l.add(null);
831		try {
665	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
666	–	l.add(new Callable<String>() {
667	–	public String call() {
668	–	try {
669	–	latch.await();
670	–	} catch (InterruptedException quittingTime) {}
671	–	return TEST_STRING;
672	–	}});
673	–	l.add(null);
832		e.invokeAny(l);
833		shouldThrow();
834		} catch (NullPointerException success) {
#	Line 685 | Line 843 | public class ScheduledExecutorTest exten
843		*/
844		public void testInvokeAny4() throws Exception {
845		ExecutorService e = new ScheduledThreadPoolExecutor(2);
846	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
847	+	l.add(new NPETask());
848		try {
689	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
690	–	l.add(new NPETask());
849		e.invokeAny(l);
850		shouldThrow();
851		} catch (ExecutionException success) {
#	Line 703 | Line 861 | public class ScheduledExecutorTest exten
861		public void testInvokeAny5() throws Exception {
862		ExecutorService e = new ScheduledThreadPoolExecutor(2);
863		try {
864	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
864	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
865		l.add(new StringTask());
866		l.add(new StringTask());
867		String result = e.invokeAny(l);
#	Line 745 | Line 903 | public class ScheduledExecutorTest exten
903		*/
904		public void testInvokeAll3() throws Exception {
905		ExecutorService e = new ScheduledThreadPoolExecutor(2);
906	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
907	+	l.add(new StringTask());
908	+	l.add(null);
909		try {
749	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
750	–	l.add(new StringTask());
751	–	l.add(null);
910		e.invokeAll(l);
911		shouldThrow();
912		} catch (NullPointerException success) {
#	Line 762 | Line 920 | public class ScheduledExecutorTest exten
920		*/
921		public void testInvokeAll4() throws Exception {
922		ExecutorService e = new ScheduledThreadPoolExecutor(2);
923	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
924	+	l.add(new NPETask());
925	+	List<Future<String>> futures = e.invokeAll(l);
926	+	assertEquals(1, futures.size());
927		try {
928	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
767	<	l.add(new NPETask());
768	<	List<Future<String>> result = e.invokeAll(l);
769	<	assertEquals(1, result.size());
770	<	for (Future<String> future : result)
771	<	future.get();
928	>	futures.get(0).get();
929		shouldThrow();
930		} catch (ExecutionException success) {
931		assertTrue(success.getCause() instanceof NullPointerException);
#	Line 783 | Line 940 | public class ScheduledExecutorTest exten
940		public void testInvokeAll5() throws Exception {
941		ExecutorService e = new ScheduledThreadPoolExecutor(2);
942		try {
943	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
943	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
944		l.add(new StringTask());
945		l.add(new StringTask());
946	<	List<Future<String>> result = e.invokeAll(l);
947	<	assertEquals(2, result.size());
948	<	for (Future<String> future : result)
946	>	List<Future<String>> futures = e.invokeAll(l);
947	>	assertEquals(2, futures.size());
948	>	for (Future<String> future : futures)
949		assertSame(TEST_STRING, future.get());
950		} finally {
951		joinPool(e);
#	Line 814 | Line 971 | public class ScheduledExecutorTest exten
971		*/
972		public void testTimedInvokeAnyNullTimeUnit() throws Exception {
973		ExecutorService e = new ScheduledThreadPoolExecutor(2);
974	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
975	+	l.add(new StringTask());
976		try {
818	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
819	–	l.add(new StringTask());
977		e.invokeAny(l, MEDIUM_DELAY_MS, null);
978		shouldThrow();
979		} catch (NullPointerException success) {
#	Line 843 | Line 1000 | public class ScheduledExecutorTest exten
1000		* timed invokeAny(c) throws NPE if c has null elements
1001		*/
1002		public void testTimedInvokeAny3() throws Exception {
1003	<	final CountDownLatch latch = new CountDownLatch(1);
1003	>	CountDownLatch latch = new CountDownLatch(1);
1004		ExecutorService e = new ScheduledThreadPoolExecutor(2);
1005	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
1006	+	l.add(latchAwaitingStringTask(latch));
1007	+	l.add(null);
1008		try {
849	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
850	–	l.add(new Callable<String>() {
851	–	public String call() {
852	–	try {
853	–	latch.await();
854	–	} catch (InterruptedException quittingTime) {}
855	–	return TEST_STRING;
856	–	}});
857	–	l.add(null);
1009		e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1010		shouldThrow();
1011		} catch (NullPointerException success) {
#	Line 869 | Line 1020 | public class ScheduledExecutorTest exten
1020		*/
1021		public void testTimedInvokeAny4() throws Exception {
1022		ExecutorService e = new ScheduledThreadPoolExecutor(2);
1023	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
1024	+	l.add(new NPETask());
1025		try {
873	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
874	–	l.add(new NPETask());
1026		e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1027		shouldThrow();
1028		} catch (ExecutionException success) {
#	Line 887 | Line 1038 | public class ScheduledExecutorTest exten
1038		public void testTimedInvokeAny5() throws Exception {
1039		ExecutorService e = new ScheduledThreadPoolExecutor(2);
1040		try {
1041	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1041	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1042		l.add(new StringTask());
1043		l.add(new StringTask());
1044		String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
#	Line 916 | Line 1067 | public class ScheduledExecutorTest exten
1067		*/
1068		public void testTimedInvokeAllNullTimeUnit() throws Exception {
1069		ExecutorService e = new ScheduledThreadPoolExecutor(2);
1070	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
1071	+	l.add(new StringTask());
1072		try {
920	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
921	–	l.add(new StringTask());
1073		e.invokeAll(l, MEDIUM_DELAY_MS, null);
1074		shouldThrow();
1075		} catch (NullPointerException success) {
#	Line 945 | Line 1096 | public class ScheduledExecutorTest exten
1096		*/
1097		public void testTimedInvokeAll3() throws Exception {
1098		ExecutorService e = new ScheduledThreadPoolExecutor(2);
1099	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
1100	+	l.add(new StringTask());
1101	+	l.add(null);
1102		try {
949	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
950	–	l.add(new StringTask());
951	–	l.add(null);
1103		e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1104		shouldThrow();
1105		} catch (NullPointerException success) {
#	Line 962 | Line 1113 | public class ScheduledExecutorTest exten
1113		*/
1114		public void testTimedInvokeAll4() throws Exception {
1115		ExecutorService e = new ScheduledThreadPoolExecutor(2);
1116	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
1117	+	l.add(new NPETask());
1118	+	List<Future<String>> futures =
1119	+	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1120	+	assertEquals(1, futures.size());
1121		try {
1122	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
967	<	l.add(new NPETask());
968	<	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
969	<	assertEquals(1, result.size());
970	<	for (Future<String> future : result)
971	<	future.get();
1122	>	futures.get(0).get();
1123		shouldThrow();
1124		} catch (ExecutionException success) {
1125		assertTrue(success.getCause() instanceof NullPointerException);
#	Line 983 | Line 1134 | public class ScheduledExecutorTest exten
1134		public void testTimedInvokeAll5() throws Exception {
1135		ExecutorService e = new ScheduledThreadPoolExecutor(2);
1136		try {
1137	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1137	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1138		l.add(new StringTask());
1139		l.add(new StringTask());
1140	<	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1141	<	assertEquals(2, result.size());
1142	<	for (Future<String> future : result)
1140	>	List<Future<String>> futures =
1141	>	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1142	>	assertEquals(2, futures.size());
1143	>	for (Future<String> future : futures)
1144		assertSame(TEST_STRING, future.get());
1145		} finally {
1146		joinPool(e);
#	Line 1001 | Line 1153 | public class ScheduledExecutorTest exten
1153		public void testTimedInvokeAll6() throws Exception {
1154		ExecutorService e = new ScheduledThreadPoolExecutor(2);
1155		try {
1156	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1156	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1157		l.add(new StringTask());
1158		l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1159		l.add(new StringTask());
1160	<	List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1161	<	assertEquals(3, result.size());
1162	<	Iterator<Future<String>> it = result.iterator();
1160	>	List<Future<String>> futures =
1161	>	e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1162	>	assertEquals(3, futures.size());
1163	>	Iterator<Future<String>> it = futures.iterator();
1164		Future<String> f1 = it.next();
1165		Future<String> f2 = it.next();
1166		Future<String> f3 = it.next();

Diff Legend

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