ViewVC Help

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

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

Comparing jsr166/src/test/tck/ForkJoinPoolTest.java (file contents):
Revision 1.5 by jsr166, Sat Aug 1 22:09:13 2009 UTC vs.
Revision 1.35 by dl, Fri Nov 19 00:20:47 2010 UTC

#	Line 4 | Line 4
4		* http://creativecommons.org/licenses/publicdomain
5		*/
6
7	–
7		import junit.framework.*;
8	<	import java.util.*;
9	<	import java.util.concurrent.*;
10	<	import java.util.concurrent.locks.*;
11	<	import java.security.*;
8	>	import java.util.ArrayList;
9	>	import java.util.Collection;
10	>	import java.util.List;
11	>	import java.util.concurrent.Executors;
12	>	import java.util.concurrent.ExecutorService;
13	>	import java.util.concurrent.AbstractExecutorService;
14	>	import java.util.concurrent.CountDownLatch;
15	>	import java.util.concurrent.Callable;
16	>	import java.util.concurrent.Future;
17	>	import java.util.concurrent.ExecutionException;
18	>	import java.util.concurrent.CancellationException;
19	>	import java.util.concurrent.RejectedExecutionException;
20	>	import java.util.concurrent.ForkJoinPool;
21	>	import java.util.concurrent.ForkJoinTask;
22	>	import java.util.concurrent.ForkJoinWorkerThread;
23	>	import java.util.concurrent.RecursiveTask;
24	>	import java.util.concurrent.TimeUnit;
25	>	import java.util.concurrent.locks.ReentrantLock;
26	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
27	>	import java.security.AccessControlException;
28	>	import java.security.Policy;
29	>	import java.security.PrivilegedAction;
30	>	import java.security.PrivilegedExceptionAction;
31
32		public class ForkJoinPoolTest extends JSR166TestCase {
33		public static void main(String[] args) {
34	<	junit.textui.TestRunner.run (suite());
34	>	junit.textui.TestRunner.run(suite());
35		}
36	+
37		public static Test suite() {
38		return new TestSuite(ForkJoinPoolTest.class);
39		}
#	Line 38 | Line 57 | public class ForkJoinPoolTest extends JS
57		// Some classes to test extension and factory methods
58
59		static class MyHandler implements Thread.UncaughtExceptionHandler {
60	<	int catches = 0;
60	>	volatile int catches = 0;
61		public void uncaughtException(Thread t, Throwable e) {
62		++catches;
63		}
#	Line 47 | Line 66 | public class ForkJoinPoolTest extends JS
66		// to test handlers
67		static class FailingFJWSubclass extends ForkJoinWorkerThread {
68		public FailingFJWSubclass(ForkJoinPool p) { super(p) ; }
69	<	protected void onStart() { throw new Error(); }
69	>	protected void onStart() { super.onStart(); throw new Error(); }
70		}
71
72	<	static class FailingThreadFactory implements ForkJoinPool.ForkJoinWorkerThreadFactory {
73	<	int calls = 0;
72	>	static class FailingThreadFactory
73	>	implements ForkJoinPool.ForkJoinWorkerThreadFactory {
74	>	volatile int calls = 0;
75		public ForkJoinWorkerThread newThread(ForkJoinPool p) {
76		if (++calls > 1) return null;
77		return new FailingFJWSubclass(p);
#	Line 140 | Line 160 | public class ForkJoinPoolTest extends JS
160		* tasks, and quiescent running state.
161		*/
162		public void testDefaultInitialState() {
163	<	ForkJoinPool p = null;
163	>	ForkJoinPool p = new ForkJoinPool(1);
164		try {
165	<	p = new ForkJoinPool(1);
166	<	assertTrue(p.getFactory() == ForkJoinPool.defaultForkJoinWorkerThreadFactory);
165	>	assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
166	>	p.getFactory());
167		assertTrue(p.isQuiescent());
148	–	assertTrue(p.getMaintainsParallelism());
168		assertFalse(p.getAsyncMode());
169	<	assertTrue(p.getActiveThreadCount() == 0);
170	<	assertTrue(p.getStealCount() == 0);
171	<	assertTrue(p.getQueuedTaskCount() == 0);
172	<	assertTrue(p.getQueuedSubmissionCount() == 0);
169	>	assertEquals(0, p.getActiveThreadCount());
170	>	assertEquals(0, p.getStealCount());
171	>	assertEquals(0, p.getQueuedTaskCount());
172	>	assertEquals(0, p.getQueuedSubmissionCount());
173		assertFalse(p.hasQueuedSubmissions());
174		assertFalse(p.isShutdown());
175		assertFalse(p.isTerminating());
#	Line 167 | Line 186 | public class ForkJoinPoolTest extends JS
186		try {
187		new ForkJoinPool(-1);
188		shouldThrow();
189	<	}
171	<	catch (IllegalArgumentException success) {}
189	>	} catch (IllegalArgumentException success) {}
190		}
191
192		/**
#	Line 176 | Line 194 | public class ForkJoinPoolTest extends JS
194		*/
195		public void testConstructor2() {
196		try {
197	<	new ForkJoinPool(1, null);
197	>	new ForkJoinPool(1, null, null, false);
198		shouldThrow();
199	<	}
182	<	catch (NullPointerException success) {}
199	>	} catch (NullPointerException success) {}
200		}
201
202
#	Line 187 | Line 204 | public class ForkJoinPoolTest extends JS
204		* getParallelism returns size set in constructor
205		*/
206		public void testGetParallelism() {
207	<	ForkJoinPool p = null;
191	<	try {
192	<	p = new ForkJoinPool(1);
193	<	assertTrue(p.getParallelism() == 1);
194	<	} finally {
195	<	joinPool(p);
196	<	}
197	<	}
198	<
199	<	/**
200	<	* setParallelism changes reported parallelism level.
201	<	*/
202	<	public void testSetParallelism() {
203	<	ForkJoinPool p = null;
204	<	try {
205	<	p = new ForkJoinPool(1);
206	<	assertTrue(p.getParallelism() == 1);
207	<	p.setParallelism(2);
208	<	assertTrue(p.getParallelism() == 2);
209	<	} finally {
210	<	joinPool(p);
211	<	}
212	<	}
213	<
214	<	/**
215	<	* setParallelism with argument <= 0 throws exception
216	<	*/
217	<	public void testSetParallelism2() {
218	<	ForkJoinPool p = null;
207	>	ForkJoinPool p = new ForkJoinPool(1);
208		try {
209	<	p = new ForkJoinPool(1);
221	<	assertTrue(p.getParallelism() == 1);
222	<	p.setParallelism(-2);
223	<	shouldThrow();
224	<	} catch (IllegalArgumentException success) {
209	>	assertEquals(1, p.getParallelism());
210		} finally {
211		joinPool(p);
212		}
#	Line 231 | Line 216 | public class ForkJoinPoolTest extends JS
216		* getPoolSize returns number of started workers.
217		*/
218		public void testGetPoolSize() {
219	<	ForkJoinPool p = null;
219	>	ForkJoinPool p = new ForkJoinPool(1);
220		try {
221	<	p = new ForkJoinPool(1);
237	<	assertTrue(p.getPoolSize() == 0);
221	>	assertEquals(0, p.getActiveThreadCount());
222		Future<String> future = p.submit(new StringTask());
223	<	assertTrue(p.getPoolSize() == 1);
240	<
241	<	} finally {
242	<	joinPool(p);
243	<	}
244	<	}
245	<
246	<	/**
247	<	* setMaximumPoolSize changes size reported by getMaximumPoolSize.
248	<	*/
249	<	public void testSetMaximumPoolSize() {
250	<	ForkJoinPool p = null;
251	<	try {
252	<	p = new ForkJoinPool(1);
253	<	p.setMaximumPoolSize(2);
254	<	assertTrue(p.getMaximumPoolSize() == 2);
255	<	} finally {
256	<	joinPool(p);
257	<	}
258	<	}
259	<
260	<	/**
261	<	* setMaximumPoolSize with argument <= 0 throws exception
262	<	*/
263	<	public void testSetMaximumPoolSize2() {
264	<	ForkJoinPool p = null;
265	<	try {
266	<	p = new ForkJoinPool(1);
267	<	p.setMaximumPoolSize(-2);
268	<	shouldThrow();
269	<	} catch (IllegalArgumentException success) {
270	<	} finally {
271	<	joinPool(p);
272	<	}
273	<	}
274	<
275	<	/**
276	<	* setMaintainsParallelism changes policy reported by
277	<	* getMaintainsParallelism.
278	<	*/
279	<	public void testSetMaintainsParallelism() {
280	<	ForkJoinPool p = null;
281	<	try {
282	<	p = new ForkJoinPool(1);
283	<	p.setMaintainsParallelism(false);
284	<	assertFalse(p.getMaintainsParallelism());
285	<	} finally {
286	<	joinPool(p);
287	<	}
288	<	}
289	<
290	<	/**
291	<	* setAsyncMode changes policy reported by
292	<	* getAsyncMode.
293	<	*/
294	<	public void testSetAsyncMode() {
295	<	ForkJoinPool p = null;
296	<	try {
297	<	p = new ForkJoinPool(1);
298	<	p.setAsyncMode(true);
299	<	assertTrue(p.getAsyncMode());
223	>	assertEquals(1, p.getPoolSize());
224		} finally {
225		joinPool(p);
226		}
#	Line 308 | Line 232 | public class ForkJoinPoolTest extends JS
232		* Additionally tests: Overriding ForkJoinWorkerThread.onStart
233		* performs its defined action
234		*/
235	<	public void testSetUncaughtExceptionHandler() {
236	<	ForkJoinPool p = null;
237	<	try {
238	<	p = new ForkJoinPool(1, new FailingThreadFactory());
239	<	MyHandler eh = new MyHandler();
240	<	p.setUncaughtExceptionHandler(eh);
241	<	assertEquals(eh, p.getUncaughtExceptionHandler());
242	<	p.execute(new FailingTask());
243	<	Thread.sleep(MEDIUM_DELAY_MS);
244	<	assertTrue(eh.catches > 0);
245	<	} catch (InterruptedException e) {
246	<	unexpectedException();
235	>	public void testSetUncaughtExceptionHandler() throws InterruptedException {
236	>	final CountDownLatch uehInvoked = new CountDownLatch(1);
237	>	final Thread.UncaughtExceptionHandler eh =
238	>	new Thread.UncaughtExceptionHandler() {
239	>	public void uncaughtException(Thread t, Throwable e) {
240	>	uehInvoked.countDown();
241	>	}};
242	>	ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
243	>	eh, false);
244	>	try {
245	>	assertSame(eh, p.getUncaughtExceptionHandler());
246	>	p.execute(new FibTask(8));
247	>	assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
248		} finally {
249	+	p.shutdownNow(); // failure might have prevented processing task
250		joinPool(p);
251		}
252		}
253
254		/**
329	–	* setUncaughtExceptionHandler of null removes handler
330	–	*/
331	–	public void testSetUncaughtExceptionHandler2() {
332	–	ForkJoinPool p = null;
333	–	try {
334	–	p = new ForkJoinPool(1);
335	–	p.setUncaughtExceptionHandler(null);
336	–	assertNull(p.getUncaughtExceptionHandler());
337	–	} finally {
338	–	joinPool(p);
339	–	}
340	–	}
341	–
342	–
343	–	/**
255		* After invoking a single task, isQuiescent is true,
256		* queues are empty, threads are not active, and
257		* construction parameters continue to hold
258		*/
259	<	public void testisQuiescent() {
260	<	ForkJoinPool p = null;
259	>	public void testisQuiescent() throws InterruptedException {
260	>	ForkJoinPool p = new ForkJoinPool(2);
261		try {
262	<	p = new ForkJoinPool(2);
262	>	assertTrue(p.isQuiescent());
263		p.invoke(new FibTask(20));
264	<	assertTrue(p.getFactory() == ForkJoinPool.defaultForkJoinWorkerThreadFactory);
265	<	Thread.sleep(MEDIUM_DELAY_MS);
264	>	assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
265	>	p.getFactory());
266	>	Thread.sleep(SMALL_DELAY_MS);
267		assertTrue(p.isQuiescent());
356	–	assertTrue(p.getMaintainsParallelism());
268		assertFalse(p.getAsyncMode());
269	<	assertTrue(p.getActiveThreadCount() == 0);
270	<	assertTrue(p.getQueuedTaskCount() == 0);
271	<	assertTrue(p.getQueuedSubmissionCount() == 0);
269	>	assertEquals(0, p.getActiveThreadCount());
270	>	assertEquals(0, p.getQueuedTaskCount());
271	>	assertEquals(0, p.getQueuedSubmissionCount());
272		assertFalse(p.hasQueuedSubmissions());
273		assertFalse(p.isShutdown());
274		assertFalse(p.isTerminating());
275		assertFalse(p.isTerminated());
365	–	} catch (InterruptedException e) {
366	–	unexpectedException();
276		} finally {
277		joinPool(p);
278		}
#	Line 372 | Line 281 | public class ForkJoinPoolTest extends JS
281		/**
282		* Completed submit(ForkJoinTask) returns result
283		*/
284	<	public void testSubmitForkJoinTask() {
285	<	ForkJoinPool p = null;
284	>	public void testSubmitForkJoinTask() throws Throwable {
285	>	ForkJoinPool p = new ForkJoinPool(1);
286		try {
378	–	p = new ForkJoinPool(1);
287		ForkJoinTask<Integer> f = p.submit(new FibTask(8));
288	<	int r = f.get();
381	<	assertTrue(r == 21);
382	<	} catch (ExecutionException ex) {
383	<	unexpectedException();
384	<	} catch (InterruptedException ex) {
385	<	unexpectedException();
288	>	assertEquals(21, (int) f.get());
289		} finally {
290		joinPool(p);
291		}
#	Line 392 | Line 295 | public class ForkJoinPoolTest extends JS
295		* A task submitted after shutdown is rejected
296		*/
297		public void testSubmitAfterShutdown() {
298	<	ForkJoinPool p = null;
298	>	ForkJoinPool p = new ForkJoinPool(1);
299		try {
397	–	p = new ForkJoinPool(1);
300		p.shutdown();
301		assertTrue(p.isShutdown());
302	<	ForkJoinTask<Integer> f = p.submit(new FibTask(8));
303	<	shouldThrow();
304	<	} catch (RejectedExecutionException success) {
302	>	try {
303	>	ForkJoinTask<Integer> f = p.submit(new FibTask(8));
304	>	shouldThrow();
305	>	} catch (RejectedExecutionException success) {}
306		} finally {
307		joinPool(p);
308		}
#	Line 408 | Line 311 | public class ForkJoinPoolTest extends JS
311		/**
312		* Pool maintains parallelism when using ManagedBlocker
313		*/
314	<	public void testBlockingForkJoinTask() {
315	<	ForkJoinPool p = null;
314	>	public void testBlockingForkJoinTask() throws Throwable {
315	>	ForkJoinPool p = new ForkJoinPool(4);
316		try {
414	–	p = new ForkJoinPool(4);
317		ReentrantLock lock = new ReentrantLock();
318		ManagedLocker locker = new ManagedLocker(lock);
319	<	ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
319	>	ForkJoinTask<Integer> f = new LockingFibTask(20, locker, lock);
320		p.execute(f);
321	<	assertTrue(p.getPoolSize() >= 4);
420	<	int r = f.get();
421	<	assertTrue(r ==  832040);
422	<	} catch (ExecutionException ex) {
423	<	unexpectedException();
424	<	} catch (InterruptedException ex) {
425	<	unexpectedException();
321	>	assertEquals(6765, (int) f.get());
322		} finally {
323	<	joinPool(p);
323	>	p.shutdownNow(); // don't wait out shutdown
324		}
325		}
326
#	Line 432 | Line 328 | public class ForkJoinPoolTest extends JS
328		* pollSubmission returns unexecuted submitted task, if present
329		*/
330		public void testPollSubmission() {
331	<	SubFJP p = null;
331	>	SubFJP p = new SubFJP();
332		try {
333	<	p = new SubFJP();
334	<	ForkJoinTask a = p.submit(new MediumRunnable());
335	<	ForkJoinTask b = p.submit(new MediumRunnable());
440	<	ForkJoinTask c = p.submit(new MediumRunnable());
333	>	ForkJoinTask a = p.submit(new ShortRunnable());
334	>	ForkJoinTask b = p.submit(new ShortRunnable());
335	>	ForkJoinTask c = p.submit(new ShortRunnable());
336		ForkJoinTask r = p.pollSubmission();
337		assertTrue(r == a || r == b || r == c);
338		assertFalse(r.isDone());
#	Line 450 | Line 345 | public class ForkJoinPoolTest extends JS
345		* drainTasksTo transfers unexecuted submitted tasks, if present
346		*/
347		public void testDrainTasksTo() {
348	<	SubFJP p = null;
348	>	SubFJP p = new SubFJP();
349		try {
350	<	p = new SubFJP();
351	<	ForkJoinTask a = p.submit(new MediumRunnable());
352	<	ForkJoinTask b = p.submit(new MediumRunnable());
458	<	ForkJoinTask c = p.submit(new MediumRunnable());
350	>	ForkJoinTask a = p.submit(new ShortRunnable());
351	>	ForkJoinTask b = p.submit(new ShortRunnable());
352	>	ForkJoinTask c = p.submit(new ShortRunnable());
353		ArrayList<ForkJoinTask> al = new ArrayList();
354		p.drainTasksTo(al);
355		assertTrue(al.size() > 0);
#	Line 474 | Line 368 | public class ForkJoinPoolTest extends JS
368		/**
369		* execute(runnable) runs it to completion
370		*/
371	<	public void testExecuteRunnable() {
371	>	public void testExecuteRunnable() throws Throwable {
372	>	ExecutorService e = new ForkJoinPool(1);
373		try {
374	<	ExecutorService e = new ForkJoinPool(1);
375	<	TrackedShortRunnable task = new TrackedShortRunnable();
481	<	assertFalse(task.done);
374	>	TrackedRunnable task = trackedRunnable(SHORT_DELAY_MS);
375	>	assertFalse(task.isDone());
376		Future<?> future = e.submit(task);
377	<	future.get();
378	<	assertTrue(task.done);
379	<	}
380	<	catch (ExecutionException ex) {
381	<	unexpectedException();
488	<	}
489	<	catch (InterruptedException ex) {
490	<	unexpectedException();
377	>	assertNull(future.get());
378	>	assertTrue(task.isDone());
379	>	assertFalse(future.isCancelled());
380	>	} finally {
381	>	joinPool(e);
382		}
383		}
384
#	Line 495 | Line 386 | public class ForkJoinPoolTest extends JS
386		/**
387		* Completed submit(callable) returns result
388		*/
389	<	public void testSubmitCallable() {
389	>	public void testSubmitCallable() throws Throwable {
390	>	ExecutorService e = new ForkJoinPool(1);
391		try {
500	–	ExecutorService e = new ForkJoinPool(1);
392		Future<String> future = e.submit(new StringTask());
393	<	String result = future.get();
394	<	assertSame(TEST_STRING, result);
395	<	}
396	<	catch (ExecutionException ex) {
397	<	unexpectedException();
507	<	}
508	<	catch (InterruptedException ex) {
509	<	unexpectedException();
393	>	assertSame(TEST_STRING, future.get());
394	>	assertTrue(future.isDone());
395	>	assertFalse(future.isCancelled());
396	>	} finally {
397	>	joinPool(e);
398		}
399		}
400
401		/**
402		* Completed submit(runnable) returns successfully
403		*/
404	<	public void testSubmitRunnable() {
404	>	public void testSubmitRunnable() throws Throwable {
405	>	ExecutorService e = new ForkJoinPool(1);
406		try {
518	–	ExecutorService e = new ForkJoinPool(1);
407		Future<?> future = e.submit(new NoOpRunnable());
408	<	future.get();
408	>	assertNull(future.get());
409		assertTrue(future.isDone());
410	<	}
411	<	catch (ExecutionException ex) {
412	<	unexpectedException();
525	<	}
526	<	catch (InterruptedException ex) {
527	<	unexpectedException();
410	>	assertFalse(future.isCancelled());
411	>	} finally {
412	>	joinPool(e);
413		}
414		}
415
416		/**
417		* Completed submit(runnable, result) returns result
418		*/
419	<	public void testSubmitRunnable2() {
419	>	public void testSubmitRunnable2() throws Throwable {
420	>	ExecutorService e = new ForkJoinPool(1);
421		try {
536	–	ExecutorService e = new ForkJoinPool(1);
422		Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
423	<	String result = future.get();
424	<	assertSame(TEST_STRING, result);
425	<	}
426	<	catch (ExecutionException ex) {
427	<	unexpectedException();
543	<	}
544	<	catch (InterruptedException ex) {
545	<	unexpectedException();
423	>	assertSame(TEST_STRING, future.get());
424	>	assertTrue(future.isDone());
425	>	assertFalse(future.isCancelled());
426	>	} finally {
427	>	joinPool(e);
428		}
429		}
430
549	–
431		/**
432	<	* A submitted privileged action to completion
432	>	* A submitted privileged action runs to completion
433		*/
434	<	public void testSubmitPrivilegedAction() {
435	<	Policy savedPolicy = null;
436	<	try {
437	<	savedPolicy = Policy.getPolicy();
438	<	AdjustablePolicy policy = new AdjustablePolicy();
558	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
559	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
560	<	Policy.setPolicy(policy);
561	<	} catch (AccessControlException ok) {
562	<	return;
563	<	}
564	<	try {
565	<	ExecutorService e = new ForkJoinPool(1);
566	<	Future future = e.submit(Executors.callable(new PrivilegedAction() {
434	>	public void testSubmitPrivilegedAction() throws Exception {
435	>	Runnable r = new CheckedRunnable() {
436	>	public void realRun() throws Exception {
437	>	ExecutorService e = new ForkJoinPool(1);
438	>	Future future = e.submit(Executors.callable(new PrivilegedAction() {
439		public Object run() {
440		return TEST_STRING;
441		}}));
442
443	<	Object result = future.get();
444	<	assertSame(TEST_STRING, result);
445	<	}
446	<	catch (ExecutionException ex) {
447	<	unexpectedException();
576	<	}
577	<	catch (InterruptedException ex) {
578	<	unexpectedException();
579	<	}
580	<	finally {
581	<	try {
582	<	Policy.setPolicy(savedPolicy);
583	<	} catch (AccessControlException ok) {
584	<	return;
585	<	}
586	<	}
443	>	assertSame(TEST_STRING, future.get());
444	>	}};
445	>
446	>	runWithPermissions(r,
447	>	new RuntimePermission("modifyThread"));
448		}
449
450		/**
451	<	* A submitted a privileged exception action runs to completion
451	>	* A submitted privileged exception action runs to completion
452		*/
453	<	public void testSubmitPrivilegedExceptionAction() {
454	<	Policy savedPolicy = null;
455	<	try {
456	<	savedPolicy = Policy.getPolicy();
457	<	AdjustablePolicy policy = new AdjustablePolicy();
597	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
598	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
599	<	Policy.setPolicy(policy);
600	<	} catch (AccessControlException ok) {
601	<	return;
602	<	}
603	<
604	<	try {
605	<	ExecutorService e = new ForkJoinPool(1);
606	<	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
453	>	public void testSubmitPrivilegedExceptionAction() throws Exception {
454	>	Runnable r = new CheckedRunnable() {
455	>	public void realRun() throws Exception {
456	>	ExecutorService e = new ForkJoinPool(1);
457	>	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
458		public Object run() {
459		return TEST_STRING;
460		}}));
461
462	<	Object result = future.get();
463	<	assertSame(TEST_STRING, result);
464	<	}
465	<	catch (ExecutionException ex) {
615	<	unexpectedException();
616	<	}
617	<	catch (InterruptedException ex) {
618	<	unexpectedException();
619	<	}
620	<	finally {
621	<	Policy.setPolicy(savedPolicy);
622	<	}
462	>	assertSame(TEST_STRING, future.get());
463	>	}};
464	>
465	>	runWithPermissions(r, new RuntimePermission("modifyThread"));
466		}
467
468		/**
469		* A submitted failed privileged exception action reports exception
470		*/
471	<	public void testSubmitFailedPrivilegedExceptionAction() {
472	<	Policy savedPolicy = null;
473	<	try {
474	<	savedPolicy = Policy.getPolicy();
475	<	AdjustablePolicy policy = new AdjustablePolicy();
633	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
634	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
635	<	Policy.setPolicy(policy);
636	<	} catch (AccessControlException ok) {
637	<	return;
638	<	}
639	<
640	<
641	<	try {
642	<	ExecutorService e = new ForkJoinPool(1);
643	<	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
471	>	public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
472	>	Runnable r = new CheckedRunnable() {
473	>	public void realRun() throws Exception {
474	>	ExecutorService e = new ForkJoinPool(1);
475	>	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
476		public Object run() throws Exception {
477		throw new IndexOutOfBoundsException();
478		}}));
479
480	<	Object result = future.get();
481	<	shouldThrow();
482	<	}
483	<	catch (ExecutionException success) {
484	<	} catch (CancellationException success) {
485	<	} catch (InterruptedException ex) {
486	<	unexpectedException();
487	<	}
656	<	finally {
657	<	Policy.setPolicy(savedPolicy);
658	<	}
480	>	try {
481	>	future.get();
482	>	shouldThrow();
483	>	} catch (ExecutionException success) {
484	>	assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
485	>	}}};
486	>
487	>	runWithPermissions(r, new RuntimePermission("modifyThread"));
488		}
489
490		/**
491	<	* execute(null runnable) throws NPE
491	>	* execute(null runnable) throws NullPointerException
492		*/
493		public void testExecuteNullRunnable() {
494	+	ExecutorService e = new ForkJoinPool(1);
495		try {
496	<	ExecutorService e = new ForkJoinPool(1);
667	<	TrackedShortRunnable task = null;
668	<	Future<?> future = e.submit(task);
496	>	Future<?> future = e.submit((Runnable) null);
497		shouldThrow();
498	<	}
499	<	catch (NullPointerException success) {
500	<	}
673	<	catch (Exception ex) {
674	<	unexpectedException();
498	>	} catch (NullPointerException success) {
499	>	} finally {
500	>	joinPool(e);
501		}
502		}
503
504
505		/**
506	<	* submit(null callable) throws NPE
506	>	* submit(null callable) throws NullPointerException
507		*/
508		public void testSubmitNullCallable() {
509	+	ExecutorService e = new ForkJoinPool(1);
510		try {
511	<	ExecutorService e = new ForkJoinPool(1);
685	<	StringTask t = null;
686	<	Future<String> future = e.submit(t);
511	>	Future<String> future = e.submit((Callable) null);
512		shouldThrow();
513	<	}
514	<	catch (NullPointerException success) {
515	<	}
691	<	catch (Exception ex) {
692	<	unexpectedException();
513	>	} catch (NullPointerException success) {
514	>	} finally {
515	>	joinPool(e);
516		}
517		}
518
519
520		/**
521	<	* Blocking on submit(callable) throws InterruptedException if
699	<	* caller interrupted.
521	>	* submit(callable).get() throws InterruptedException if interrupted
522		*/
523	<	public void testInterruptedSubmit() {
524	<	final ForkJoinPool p = new ForkJoinPool(1);
525	<	Thread t = new Thread(new Runnable() {
526	<	public void run() {
527	<	try {
528	<	p.submit(new Callable<Object>() {
529	<	public Object call() {
530	<	try {
531	<	Thread.sleep(MEDIUM_DELAY_MS);
532	<	shouldThrow();
533	<	} catch (InterruptedException e) {
534	<	}
535	<	return null;
536	<	}
537	<	}).get();
538	<	} catch (InterruptedException success) {
717	<	} catch (Exception e) {
718	<	unexpectedException();
719	<	}
720	<
721	<	}
722	<	});
723	<	try {
523	>	public void testInterruptedSubmit() throws InterruptedException {
524	>	final CountDownLatch submitted    = new CountDownLatch(1);
525	>	final CountDownLatch quittingTime = new CountDownLatch(1);
526	>	final ExecutorService p = new ForkJoinPool(1);
527	>	final Callable<Void> awaiter = new CheckedCallable<Void>() {
528	>	public Void realCall() throws InterruptedException {
529	>	assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS));
530	>	return null;
531	>	}};
532	>	try {
533	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
534	>	public void realRun() throws Exception {
535	>	Future<Void> future = p.submit(awaiter);
536	>	submitted.countDown();
537	>	future.get();
538	>	}});
539		t.start();
540	<	Thread.sleep(SHORT_DELAY_MS);
540	>	assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS));
541		t.interrupt();
542	<	} catch (Exception e) {
543	<	unexpectedException();
542	>	t.join();
543	>	} finally {
544	>	quittingTime.countDown();
545	>	joinPool(p);
546		}
730	–	joinPool(p);
547		}
548
549		/**
550		* get of submit(callable) throws ExecutionException if callable
551		* throws exception
552		*/
553	<	public void testSubmitEE() {
553	>	public void testSubmitEE() throws Throwable {
554		ForkJoinPool p = new ForkJoinPool(1);
739	–
555		try {
556	<	Callable c = new Callable() {
557	<	public Object call() {
558	<	int i = 5/0;
559	<	return Boolean.TRUE;
560	<	}
746	<	};
747	<
748	<	for (int i = 0; i < 5; i++) {
749	<	p.submit(c).get();
750	<	}
751	<
556	>	p.submit(new Callable() {
557	>	public Object call() {
558	>	int i = 5/0;
559	>	return Boolean.TRUE;
560	>	}}).get();
561		shouldThrow();
562		} catch (ExecutionException success) {
563	<	} catch (CancellationException success) {
564	<	} catch (Exception e) {
565	<	unexpectedException();
563	>	assertTrue(success.getCause() instanceof ArithmeticException);
564	>	} finally {
565	>	joinPool(p);
566		}
758	–	joinPool(p);
567		}
568
569		/**
570	<	* invokeAny(null) throws NPE
570	>	* invokeAny(null) throws NullPointerException
571		*/
572	<	public void testInvokeAny1() {
572	>	public void testInvokeAny1() throws Throwable {
573		ExecutorService e = new ForkJoinPool(1);
574		try {
575		e.invokeAny(null);
576	+	shouldThrow();
577		} catch (NullPointerException success) {
769	–	} catch (Exception ex) {
770	–	unexpectedException();
578		} finally {
579		joinPool(e);
580		}
581		}
582
583		/**
584	<	* invokeAny(empty collection) throws IAE
584	>	* invokeAny(empty collection) throws IllegalArgumentException
585		*/
586	<	public void testInvokeAny2() {
586	>	public void testInvokeAny2() throws Throwable {
587		ExecutorService e = new ForkJoinPool(1);
588		try {
589		e.invokeAny(new ArrayList<Callable<String>>());
590	+	shouldThrow();
591		} catch (IllegalArgumentException success) {
784	–	} catch (Exception ex) {
785	–	unexpectedException();
592		} finally {
593		joinPool(e);
594		}
595		}
596
597		/**
598	<	* invokeAny(c) throws NPE if c has null elements
598	>	* invokeAny(c) throws NullPointerException if c has a single null element
599		*/
600	<	public void testInvokeAny3() {
600	>	public void testInvokeAny3() throws Throwable {
601		ExecutorService e = new ForkJoinPool(1);
602	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
603	+	l.add(null);
604	+	try {
605	+	e.invokeAny(l);
606	+	shouldThrow();
607	+	} catch (NullPointerException success) {
608	+	} finally {
609	+	joinPool(e);
610	+	}
611	+	}
612	+
613	+	/**
614	+	* invokeAny(c) throws NullPointerException if c has null elements
615	+	*/
616	+	public void testInvokeAny4() throws Throwable {
617	+	CountDownLatch latch = new CountDownLatch(1);
618	+	ExecutorService e = new ForkJoinPool(1);
619	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
620	+	l.add(latchAwaitingStringTask(latch));
621	+	l.add(null);
622		try {
797	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
798	–	l.add(new StringTask());
799	–	l.add(null);
623		e.invokeAny(l);
624	+	shouldThrow();
625		} catch (NullPointerException success) {
802	–	} catch (Exception ex) {
803	–	ex.printStackTrace();
804	–	unexpectedException();
626		} finally {
627	+	latch.countDown();
628		joinPool(e);
629		}
630		}
#	Line 810 | Line 632 | public class ForkJoinPoolTest extends JS
632		/**
633		* invokeAny(c) throws ExecutionException if no task in c completes
634		*/
635	<	public void testInvokeAny4() {
635	>	public void testInvokeAny5() throws Throwable {
636		ExecutorService e = new ForkJoinPool(1);
637	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
638	+	l.add(new NPETask());
639		try {
816	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
817	–	l.add(new NPETask());
640		e.invokeAny(l);
641	+	shouldThrow();
642		} catch (ExecutionException success) {
643	<	} catch (CancellationException success) {
821	<	} catch (Exception ex) {
822	<	unexpectedException();
643	>	assertTrue(success.getCause() instanceof NullPointerException);
644		} finally {
645		joinPool(e);
646		}
#	Line 828 | Line 649 | public class ForkJoinPoolTest extends JS
649		/**
650		* invokeAny(c) returns result of some task in c if at least one completes
651		*/
652	<	public void testInvokeAny5() {
652	>	public void testInvokeAny6() throws Throwable {
653		ExecutorService e = new ForkJoinPool(1);
654		try {
655	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
655	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
656		l.add(new StringTask());
657		l.add(new StringTask());
658		String result = e.invokeAny(l);
659		assertSame(TEST_STRING, result);
839	–	} catch (ExecutionException success) {
840	–	} catch (CancellationException success) {
841	–	} catch (Exception ex) {
842	–	unexpectedException();
660		} finally {
661		joinPool(e);
662		}
663		}
664
665		/**
666	<	* invokeAll(null) throws NPE
666	>	* invokeAll(null) throws NullPointerException
667		*/
668	<	public void testInvokeAll1() {
668	>	public void testInvokeAll1() throws Throwable {
669		ExecutorService e = new ForkJoinPool(1);
670		try {
671		e.invokeAll(null);
672	+	shouldThrow();
673		} catch (NullPointerException success) {
856	–	} catch (Exception ex) {
857	–	unexpectedException();
674		} finally {
675		joinPool(e);
676		}
#	Line 863 | Line 679 | public class ForkJoinPoolTest extends JS
679		/**
680		* invokeAll(empty collection) returns empty collection
681		*/
682	<	public void testInvokeAll2() {
682	>	public void testInvokeAll2() throws InterruptedException {
683		ExecutorService e = new ForkJoinPool(1);
684		try {
685	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
685	>	List<Future<String>> r
686	>	= e.invokeAll(new ArrayList<Callable<String>>());
687		assertTrue(r.isEmpty());
871	–	} catch (Exception ex) {
872	–	unexpectedException();
688		} finally {
689		joinPool(e);
690		}
691		}
692
693		/**
694	<	* invokeAll(c) throws NPE if c has null elements
694	>	* invokeAll(c) throws NullPointerException if c has null elements
695		*/
696	<	public void testInvokeAll3() {
696	>	public void testInvokeAll3() throws InterruptedException {
697		ExecutorService e = new ForkJoinPool(1);
698	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
699	+	l.add(new StringTask());
700	+	l.add(null);
701		try {
884	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
885	–	l.add(new StringTask());
886	–	l.add(null);
702		e.invokeAll(l);
703	+	shouldThrow();
704		} catch (NullPointerException success) {
889	–	} catch (Exception ex) {
890	–	unexpectedException();
705		} finally {
706		joinPool(e);
707		}
708		}
709
710		/**
711	<	* get of returned element of invokeAll(c) throws exception on failed task
711	>	* get of returned element of invokeAll(c) throws
712	>	* ExecutionException on failed task
713		*/
714	<	public void testInvokeAll4() {
714	>	public void testInvokeAll4() throws Throwable {
715		ExecutorService e = new ForkJoinPool(1);
716	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
717	+	l.add(new NPETask());
718	+	List<Future<String>> futures = e.invokeAll(l);
719	+	assertEquals(1, futures.size());
720		try {
721	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
722	<	l.add(new NPETask());
904	<	List<Future<String>> result = e.invokeAll(l);
905	<	assertEquals(1, result.size());
906	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
907	<	it.next().get();
721	>	futures.get(0).get();
722	>	shouldThrow();
723		} catch (ExecutionException success) {
724	<	} catch (CancellationException success) {
910	<	} catch (Exception ex) {
911	<	ex.printStackTrace();
912	<	unexpectedException();
724	>	assertTrue(success.getCause() instanceof NullPointerException);
725		} finally {
726		joinPool(e);
727		}
#	Line 918 | Line 730 | public class ForkJoinPoolTest extends JS
730		/**
731		* invokeAll(c) returns results of all completed tasks in c
732		*/
733	<	public void testInvokeAll5() {
733	>	public void testInvokeAll5() throws Throwable {
734		ExecutorService e = new ForkJoinPool(1);
735		try {
736	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
736	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
737		l.add(new StringTask());
738		l.add(new StringTask());
739	<	List<Future<String>> result = e.invokeAll(l);
740	<	assertEquals(2, result.size());
741	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
742	<	assertSame(TEST_STRING, it.next().get());
931	<	} catch (ExecutionException success) {
932	<	} catch (CancellationException success) {
933	<	} catch (Exception ex) {
934	<	ex.printStackTrace();
935	<	unexpectedException();
739	>	List<Future<String>> futures = e.invokeAll(l);
740	>	assertEquals(2, futures.size());
741	>	for (Future<String> future : futures)
742	>	assertSame(TEST_STRING, future.get());
743		} finally {
744		joinPool(e);
745		}
#	Line 940 | Line 747 | public class ForkJoinPoolTest extends JS
747
748
749		/**
750	<	* timed invokeAny(null) throws NPE
750	>	* timed invokeAny(null) throws NullPointerException
751		*/
752	<	public void testTimedInvokeAny1() {
752	>	public void testTimedInvokeAny1() throws Throwable {
753		ExecutorService e = new ForkJoinPool(1);
754		try {
755	<	e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
755	>	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
756	>	shouldThrow();
757		} catch (NullPointerException success) {
950	–	} catch (Exception ex) {
951	–	ex.printStackTrace();
952	–	unexpectedException();
758		} finally {
759		joinPool(e);
760		}
761		}
762
763		/**
764	<	* timed invokeAny(null time unit) throws NPE
764	>	* timed invokeAny(null time unit) throws NullPointerException
765		*/
766	<	public void testTimedInvokeAnyNullTimeUnit() {
766	>	public void testTimedInvokeAnyNullTimeUnit() throws Throwable {
767		ExecutorService e = new ForkJoinPool(1);
768	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
769	+	l.add(new StringTask());
770		try {
964	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
965	–	l.add(new StringTask());
771		e.invokeAny(l, MEDIUM_DELAY_MS, null);
772	+	shouldThrow();
773		} catch (NullPointerException success) {
968	–	} catch (Exception ex) {
969	–	ex.printStackTrace();
970	–	unexpectedException();
774		} finally {
775		joinPool(e);
776		}
777		}
778
779		/**
780	<	* timed invokeAny(empty collection) throws IAE
780	>	* timed invokeAny(empty collection) throws IllegalArgumentException
781		*/
782	<	public void testTimedInvokeAny2() {
782	>	public void testTimedInvokeAny2() throws Throwable {
783		ExecutorService e = new ForkJoinPool(1);
784		try {
785	<	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
785	>	e.invokeAny(new ArrayList<Callable<String>>(),
786	>	MEDIUM_DELAY_MS, MILLISECONDS);
787	>	shouldThrow();
788		} catch (IllegalArgumentException success) {
984	–	} catch (Exception ex) {
985	–	ex.printStackTrace();
986	–	unexpectedException();
789		} finally {
790		joinPool(e);
791		}
792		}
793
794		/**
795	<	* timed invokeAny(c) throws NPE if c has null elements
795	>	* timed invokeAny(c) throws NullPointerException if c has null elements
796		*/
797	<	public void testTimedInvokeAny3() {
797	>	public void testTimedInvokeAny3() throws Throwable {
798	>	CountDownLatch latch = new CountDownLatch(1);
799		ExecutorService e = new ForkJoinPool(1);
800	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
801	+	l.add(latchAwaitingStringTask(latch));
802	+	l.add(null);
803		try {
804	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
805	<	l.add(new StringTask());
1000	<	l.add(null);
1001	<	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
804	>	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
805	>	shouldThrow();
806		} catch (NullPointerException success) {
1003	–	} catch (Exception ex) {
1004	–	ex.printStackTrace();
1005	–	unexpectedException();
807		} finally {
808	+	latch.countDown();
809		joinPool(e);
810		}
811		}
#	Line 1011 | Line 813 | public class ForkJoinPoolTest extends JS
813		/**
814		* timed invokeAny(c) throws ExecutionException if no task completes
815		*/
816	<	public void testTimedInvokeAny4() {
816	>	public void testTimedInvokeAny4() throws Throwable {
817		ExecutorService e = new ForkJoinPool(1);
818	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
819	+	l.add(new NPETask());
820		try {
821	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
822	<	l.add(new NPETask());
1019	<	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
821	>	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
822	>	shouldThrow();
823		} catch (ExecutionException success) {
824	<	} catch (CancellationException success) {
1022	<	} catch (Exception ex) {
1023	<	ex.printStackTrace();
1024	<	unexpectedException();
824	>	assertTrue(success.getCause() instanceof NullPointerException);
825		} finally {
826		joinPool(e);
827		}
#	Line 1030 | Line 830 | public class ForkJoinPoolTest extends JS
830		/**
831		* timed invokeAny(c) returns result of some task in c
832		*/
833	<	public void testTimedInvokeAny5() {
833	>	public void testTimedInvokeAny5() throws Throwable {
834		ExecutorService e = new ForkJoinPool(1);
835		try {
836	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
836	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
837		l.add(new StringTask());
838		l.add(new StringTask());
839	<	String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
839	>	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
840		assertSame(TEST_STRING, result);
1041	–	} catch (ExecutionException success) {
1042	–	} catch (CancellationException success) {
1043	–	} catch (Exception ex) {
1044	–	ex.printStackTrace();
1045	–	unexpectedException();
841		} finally {
842		joinPool(e);
843		}
844		}
845
846		/**
847	<	* timed invokeAll(null) throws NPE
847	>	* timed invokeAll(null) throws NullPointerException
848		*/
849	<	public void testTimedInvokeAll1() {
849	>	public void testTimedInvokeAll1() throws Throwable {
850		ExecutorService e = new ForkJoinPool(1);
851		try {
852	<	e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
852	>	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
853	>	shouldThrow();
854		} catch (NullPointerException success) {
1059	–	} catch (Exception ex) {
1060	–	ex.printStackTrace();
1061	–	unexpectedException();
855		} finally {
856		joinPool(e);
857		}
858		}
859
860		/**
861	<	* timed invokeAll(null time unit) throws NPE
861	>	* timed invokeAll(null time unit) throws NullPointerException
862		*/
863	<	public void testTimedInvokeAllNullTimeUnit() {
863	>	public void testTimedInvokeAllNullTimeUnit() throws Throwable {
864		ExecutorService e = new ForkJoinPool(1);
865	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
866	+	l.add(new StringTask());
867		try {
1073	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1074	–	l.add(new StringTask());
868		e.invokeAll(l, MEDIUM_DELAY_MS, null);
869	+	shouldThrow();
870		} catch (NullPointerException success) {
1077	–	} catch (Exception ex) {
1078	–	ex.printStackTrace();
1079	–	unexpectedException();
871		} finally {
872		joinPool(e);
873		}
#	Line 1085 | Line 876 | public class ForkJoinPoolTest extends JS
876		/**
877		* timed invokeAll(empty collection) returns empty collection
878		*/
879	<	public void testTimedInvokeAll2() {
879	>	public void testTimedInvokeAll2() throws InterruptedException {
880		ExecutorService e = new ForkJoinPool(1);
881		try {
882	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
882	>	List<Future<String>> r
883	>	= e.invokeAll(new ArrayList<Callable<String>>(),
884	>	MEDIUM_DELAY_MS, MILLISECONDS);
885		assertTrue(r.isEmpty());
1093	–	} catch (Exception ex) {
1094	–	ex.printStackTrace();
1095	–	unexpectedException();
886		} finally {
887		joinPool(e);
888		}
889		}
890
891		/**
892	<	* timed invokeAll(c) throws NPE if c has null elements
892	>	* timed invokeAll(c) throws NullPointerException if c has null elements
893		*/
894	<	public void testTimedInvokeAll3() {
894	>	public void testTimedInvokeAll3() throws InterruptedException {
895		ExecutorService e = new ForkJoinPool(1);
896	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
897	+	l.add(new StringTask());
898	+	l.add(null);
899		try {
900	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
901	<	l.add(new StringTask());
1109	<	l.add(null);
1110	<	e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
900	>	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
901	>	shouldThrow();
902		} catch (NullPointerException success) {
1112	–	} catch (Exception ex) {
1113	–	ex.printStackTrace();
1114	–	unexpectedException();
903		} finally {
904		joinPool(e);
905		}
#	Line 1120 | Line 908 | public class ForkJoinPoolTest extends JS
908		/**
909		* get of returned element of invokeAll(c) throws exception on failed task
910		*/
911	<	public void testTimedInvokeAll4() {
911	>	public void testTimedInvokeAll4() throws Throwable {
912		ExecutorService e = new ForkJoinPool(1);
913	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
914	+	l.add(new NPETask());
915	+	List<Future<String>> futures
916	+	= e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
917	+	assertEquals(1, futures.size());
918		try {
919	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
920	<	l.add(new NPETask());
1128	<	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1129	<	assertEquals(1, result.size());
1130	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1131	<	it.next().get();
919	>	futures.get(0).get();
920	>	shouldThrow();
921		} catch (ExecutionException success) {
922	<	} catch (CancellationException success) {
1134	<	} catch (Exception ex) {
1135	<	ex.printStackTrace();
1136	<	unexpectedException();
922	>	assertTrue(success.getCause() instanceof NullPointerException);
923		} finally {
924		joinPool(e);
925		}
#	Line 1142 | Line 928 | public class ForkJoinPoolTest extends JS
928		/**
929		* timed invokeAll(c) returns results of all completed tasks in c
930		*/
931	<	public void testTimedInvokeAll5() {
931	>	public void testTimedInvokeAll5() throws Throwable {
932		ExecutorService e = new ForkJoinPool(1);
933		try {
934	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
934	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
935		l.add(new StringTask());
936		l.add(new StringTask());
937	<	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
938	<	assertEquals(2, result.size());
939	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
940	<	assertSame(TEST_STRING, it.next().get());
941	<	} catch (ExecutionException success) {
1156	<	} catch (CancellationException success) {
1157	<	} catch (Exception ex) {
1158	<	ex.printStackTrace();
1159	<	unexpectedException();
937	>	List<Future<String>> futures
938	>	= e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
939	>	assertEquals(2, futures.size());
940	>	for (Future<String> future : futures)
941	>	assertSame(TEST_STRING, future.get());
942		} finally {
943		joinPool(e);
944		}

Diff Legend

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