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.12 by jsr166, Sat Nov 21 20:10:48 2009 UTC vs.
Revision 1.51 by jsr166, Fri Jul 26 16:36:21 2013 UTC

#	Line 1 | Line 1
1		/*
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/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	–
7		import junit.framework.*;
8	<	import java.util.*;
9	<	import java.util.concurrent.*;
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.atomic.AtomicBoolean;
26	>	import java.util.concurrent.locks.ReentrantLock;
27		import static java.util.concurrent.TimeUnit.MILLISECONDS;
28	<	import java.util.concurrent.locks.*;
29	<	import java.security.*;
28	>	import static java.util.concurrent.TimeUnit.NANOSECONDS;
29	>	import java.security.AccessControlException;
30	>	import java.security.Policy;
31	>	import java.security.PrivilegedAction;
32	>	import java.security.PrivilegedExceptionAction;
33
34		public class ForkJoinPoolTest extends JSR166TestCase {
35		public static void main(String[] args) {
36	<	junit.textui.TestRunner.run (suite());
36	>	junit.textui.TestRunner.run(suite());
37		}
38	+
39		public static Test suite() {
40		return new TestSuite(ForkJoinPoolTest.class);
41		}
42
43	<	/**
43	>	/*
44		* Testing coverage notes:
45		*
46		* 1. shutdown and related methods are tested via super.joinPool.
#	Line 39 | Line 59 | public class ForkJoinPoolTest extends JS
59		// Some classes to test extension and factory methods
60
61		static class MyHandler implements Thread.UncaughtExceptionHandler {
62	<	int catches = 0;
62	>	volatile int catches = 0;
63		public void uncaughtException(Thread t, Throwable e) {
64		++catches;
65		}
#	Line 48 | Line 68 | public class ForkJoinPoolTest extends JS
68		// to test handlers
69		static class FailingFJWSubclass extends ForkJoinWorkerThread {
70		public FailingFJWSubclass(ForkJoinPool p) { super(p) ; }
71	<	protected void onStart() { throw new Error(); }
71	>	protected void onStart() { super.onStart(); throw new Error(); }
72		}
73
74		static class FailingThreadFactory
75		implements ForkJoinPool.ForkJoinWorkerThreadFactory {
76	<	int calls = 0;
76	>	volatile int calls = 0;
77		public ForkJoinWorkerThread newThread(ForkJoinPool p) {
78		if (++calls > 1) return null;
79		return new FailingFJWSubclass(p);
#	Line 88 | Line 108 | public class ForkJoinPoolTest extends JS
108		static final class FibTask extends RecursiveTask<Integer> {
109		final int number;
110		FibTask(int n) { number = n; }
111	<	public Integer compute() {
111	>	protected Integer compute() {
112		int n = number;
113		if (n <= 1)
114		return n;
#	Line 116 | Line 136 | public class ForkJoinPoolTest extends JS
136		this.locker = locker;
137		this.lock = lock;
138		}
139	<	public Integer compute() {
139	>	protected Integer compute() {
140		int n;
141		LockingFibTask f1 = null;
142		LockingFibTask f2 = null;
#	Line 142 | Line 162 | public class ForkJoinPoolTest extends JS
162		* tasks, and quiescent running state.
163		*/
164		public void testDefaultInitialState() {
165	<	ForkJoinPool p = null;
165	>	ForkJoinPool p = new ForkJoinPool(1);
166		try {
167	<	p = new ForkJoinPool(1);
168	<	assertTrue(p.getFactory() ==
149	<	ForkJoinPool.defaultForkJoinWorkerThreadFactory);
150	<	assertTrue(p.isQuiescent());
151	<	assertTrue(p.getMaintainsParallelism());
167	>	assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
168	>	p.getFactory());
169		assertFalse(p.getAsyncMode());
170	<	assertTrue(p.getActiveThreadCount() == 0);
171	<	assertTrue(p.getStealCount() == 0);
172	<	assertTrue(p.getQueuedTaskCount() == 0);
173	<	assertTrue(p.getQueuedSubmissionCount() == 0);
170	>	assertEquals(0, p.getActiveThreadCount());
171	>	assertEquals(0, p.getStealCount());
172	>	assertEquals(0, p.getQueuedTaskCount());
173	>	assertEquals(0, p.getQueuedSubmissionCount());
174		assertFalse(p.hasQueuedSubmissions());
175		assertFalse(p.isShutdown());
176		assertFalse(p.isTerminating());
#	Line 178 | Line 195 | public class ForkJoinPoolTest extends JS
195		*/
196		public void testConstructor2() {
197		try {
198	<	new ForkJoinPool(1, null);
198	>	new ForkJoinPool(1, null, null, false);
199		shouldThrow();
200		} catch (NullPointerException success) {}
201		}
202
186	–
203		/**
204		* getParallelism returns size set in constructor
205		*/
206		public void testGetParallelism() {
207	<	ForkJoinPool p = null;
192	<	try {
193	<	p = new ForkJoinPool(1);
194	<	assertTrue(p.getParallelism() == 1);
195	<	} finally {
196	<	joinPool(p);
197	<	}
198	<	}
199	<
200	<	/**
201	<	* setParallelism changes reported parallelism level.
202	<	*/
203	<	public void testSetParallelism() {
204	<	ForkJoinPool p = null;
205	<	try {
206	<	p = new ForkJoinPool(1);
207	<	assertTrue(p.getParallelism() == 1);
208	<	p.setParallelism(2);
209	<	assertTrue(p.getParallelism() == 2);
210	<	} finally {
211	<	joinPool(p);
212	<	}
213	<	}
214	<
215	<	/**
216	<	* setParallelism with argument <= 0 throws exception
217	<	*/
218	<	public void testSetParallelism2() {
219	<	ForkJoinPool p = null;
207	>	ForkJoinPool p = new ForkJoinPool(1);
208		try {
209	<	p = new ForkJoinPool(1);
222	<	assertTrue(p.getParallelism() == 1);
223	<	p.setParallelism(-2);
224	<	shouldThrow();
225	<	} catch (IllegalArgumentException success) {
209	>	assertEquals(1, p.getParallelism());
210		} finally {
211		joinPool(p);
212		}
#	Line 232 | 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);
238	<	assertTrue(p.getPoolSize() == 0);
221	>	assertEquals(0, p.getActiveThreadCount());
222		Future<String> future = p.submit(new StringTask());
223	<	assertTrue(p.getPoolSize() == 1);
241	<
242	<	} finally {
243	<	joinPool(p);
244	<	}
245	<	}
246	<
247	<	/**
248	<	* setMaximumPoolSize changes size reported by getMaximumPoolSize.
249	<	*/
250	<	public void testSetMaximumPoolSize() {
251	<	ForkJoinPool p = null;
252	<	try {
253	<	p = new ForkJoinPool(1);
254	<	p.setMaximumPoolSize(2);
255	<	assertTrue(p.getMaximumPoolSize() == 2);
256	<	} finally {
257	<	joinPool(p);
258	<	}
259	<	}
260	<
261	<	/**
262	<	* setMaximumPoolSize with argument <= 0 throws exception
263	<	*/
264	<	public void testSetMaximumPoolSize2() {
265	<	ForkJoinPool p = null;
266	<	try {
267	<	p = new ForkJoinPool(1);
268	<	p.setMaximumPoolSize(-2);
269	<	shouldThrow();
270	<	} catch (IllegalArgumentException success) {
223	>	assertEquals(1, p.getPoolSize());
224		} finally {
225		joinPool(p);
226		}
227		}
228
229		/**
230	<	* setMaintainsParallelism changes policy reported by
278	<	* getMaintainsParallelism.
230	>	* awaitTermination on a non-shutdown pool times out
231		*/
232	<	public void testSetMaintainsParallelism() {
233	<	ForkJoinPool p = null;
234	<	try {
235	<	p = new ForkJoinPool(1);
236	<	p.setMaintainsParallelism(false);
237	<	assertFalse(p.getMaintainsParallelism());
238	<	} finally {
239	<	joinPool(p);
240	<	}
241	<	}
242	<
243	<	/**
244	<	* setAsyncMode changes policy reported by
245	<	* getAsyncMode.
246	<	*/
247	<	public void testSetAsyncMode() {
248	<	ForkJoinPool p = null;
249	<	try {
250	<	p = new ForkJoinPool(1);
251	<	p.setAsyncMode(true);
252	<	assertTrue(p.getAsyncMode());
253	<	} finally {
302	<	joinPool(p);
303	<	}
232	>	public void testAwaitTermination_timesOut() throws InterruptedException {
233	>	ForkJoinPool p = new ForkJoinPool(1);
234	>	assertFalse(p.isTerminated());
235	>	assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
236	>	assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
237	>	assertFalse(p.awaitTermination(-1L, NANOSECONDS));
238	>	assertFalse(p.awaitTermination(-1L, MILLISECONDS));
239	>	assertFalse(p.awaitTermination(0L, NANOSECONDS));
240	>	assertFalse(p.awaitTermination(0L, MILLISECONDS));
241	>	long timeoutNanos = 999999L;
242	>	long startTime = System.nanoTime();
243	>	assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
244	>	assertTrue(System.nanoTime() - startTime >= timeoutNanos);
245	>	assertFalse(p.isTerminated());
246	>	startTime = System.nanoTime();
247	>	long timeoutMillis = timeoutMillis();
248	>	assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
249	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
250	>	assertFalse(p.isTerminated());
251	>	p.shutdown();
252	>	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
253	>	assertTrue(p.isTerminated());
254		}
255
256		/**
#	Line 310 | Line 260 | public class ForkJoinPoolTest extends JS
260		* performs its defined action
261		*/
262		public void testSetUncaughtExceptionHandler() throws InterruptedException {
263	<	ForkJoinPool p = null;
264	<	try {
265	<	p = new ForkJoinPool(1, new FailingThreadFactory());
266	<	MyHandler eh = new MyHandler();
267	<	p.setUncaughtExceptionHandler(eh);
268	<	assertEquals(eh, p.getUncaughtExceptionHandler());
269	<	p.execute(new FailingTask());
270	<	Thread.sleep(MEDIUM_DELAY_MS);
271	<	assertTrue(eh.catches > 0);
263	>	final CountDownLatch uehInvoked = new CountDownLatch(1);
264	>	final Thread.UncaughtExceptionHandler eh =
265	>	new Thread.UncaughtExceptionHandler() {
266	>	public void uncaughtException(Thread t, Throwable e) {
267	>	uehInvoked.countDown();
268	>	}};
269	>	ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
270	>	eh, false);
271	>	try {
272	>	assertSame(eh, p.getUncaughtExceptionHandler());
273	>	try {
274	>	p.execute(new FibTask(8));
275	>	assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
276	>	} catch (RejectedExecutionException ok) {
277	>	}
278		} finally {
279	+	p.shutdownNow(); // failure might have prevented processing task
280		joinPool(p);
281		}
282		}
283
284		/**
285	<	* setUncaughtExceptionHandler of null removes handler
285	>	* After invoking a single task, isQuiescent eventually becomes
286	>	* true, at which time queues are empty, threads are not active,
287	>	* the task has completed successfully, and construction
288	>	* parameters continue to hold
289		*/
290	<	public void testSetUncaughtExceptionHandler2() {
291	<	ForkJoinPool p = null;
290	>	public void testIsQuiescent() throws Exception {
291	>	ForkJoinPool p = new ForkJoinPool(2);
292		try {
293	<	p = new ForkJoinPool(1);
294	<	p.setUncaughtExceptionHandler(null);
295	<	assertNull(p.getUncaughtExceptionHandler());
296	<	} finally {
297	<	joinPool(p);
298	<	}
299	<	}
300	<
293	>	assertTrue(p.isQuiescent());
294	>	long startTime = System.nanoTime();
295	>	FibTask f = new FibTask(20);
296	>	p.invoke(f);
297	>	assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
298	>	p.getFactory());
299	>	while (! p.isQuiescent()) {
300	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
301	>	throw new AssertionFailedError("timed out");
302	>	assertFalse(p.getAsyncMode());
303	>	assertFalse(p.isShutdown());
304	>	assertFalse(p.isTerminating());
305	>	assertFalse(p.isTerminated());
306	>	Thread.yield();
307	>	}
308
342	–	/**
343	–	* After invoking a single task, isQuiescent is true,
344	–	* queues are empty, threads are not active, and
345	–	* construction parameters continue to hold
346	–	*/
347	–	public void testisQuiescent() throws InterruptedException {
348	–	ForkJoinPool p = null;
349	–	try {
350	–	p = new ForkJoinPool(2);
351	–	p.invoke(new FibTask(20));
352	–	assertTrue(p.getFactory() ==
353	–	ForkJoinPool.defaultForkJoinWorkerThreadFactory);
354	–	Thread.sleep(MEDIUM_DELAY_MS);
309		assertTrue(p.isQuiescent());
356	–	assertTrue(p.getMaintainsParallelism());
310		assertFalse(p.getAsyncMode());
311	<	assertTrue(p.getActiveThreadCount() == 0);
312	<	assertTrue(p.getQueuedTaskCount() == 0);
313	<	assertTrue(p.getQueuedSubmissionCount() == 0);
311	>	assertEquals(0, p.getActiveThreadCount());
312	>	assertEquals(0, p.getQueuedTaskCount());
313	>	assertEquals(0, p.getQueuedSubmissionCount());
314		assertFalse(p.hasQueuedSubmissions());
315		assertFalse(p.isShutdown());
316		assertFalse(p.isTerminating());
317		assertFalse(p.isTerminated());
318	+	assertTrue(f.isDone());
319	+	assertEquals(6765, (int) f.get());
320		} finally {
321		joinPool(p);
322		}
#	Line 371 | Line 326 | public class ForkJoinPoolTest extends JS
326		* Completed submit(ForkJoinTask) returns result
327		*/
328		public void testSubmitForkJoinTask() throws Throwable {
329	<	ForkJoinPool p = null;
329	>	ForkJoinPool p = new ForkJoinPool(1);
330		try {
376	–	p = new ForkJoinPool(1);
331		ForkJoinTask<Integer> f = p.submit(new FibTask(8));
332	<	int r = f.get();
379	<	assertTrue(r == 21);
332	>	assertEquals(21, (int) f.get());
333		} finally {
334		joinPool(p);
335		}
#	Line 386 | Line 339 | public class ForkJoinPoolTest extends JS
339		* A task submitted after shutdown is rejected
340		*/
341		public void testSubmitAfterShutdown() {
342	<	ForkJoinPool p = null;
342	>	ForkJoinPool p = new ForkJoinPool(1);
343		try {
391	–	p = new ForkJoinPool(1);
344		p.shutdown();
345		assertTrue(p.isShutdown());
346	<	ForkJoinTask<Integer> f = p.submit(new FibTask(8));
347	<	shouldThrow();
348	<	} catch (RejectedExecutionException success) {
346	>	try {
347	>	ForkJoinTask<Integer> f = p.submit(new FibTask(8));
348	>	shouldThrow();
349	>	} catch (RejectedExecutionException success) {}
350		} finally {
351		joinPool(p);
352		}
#	Line 403 | Line 356 | public class ForkJoinPoolTest extends JS
356		* Pool maintains parallelism when using ManagedBlocker
357		*/
358		public void testBlockingForkJoinTask() throws Throwable {
359	<	ForkJoinPool p = null;
359	>	ForkJoinPool p = new ForkJoinPool(4);
360		try {
408	–	p = new ForkJoinPool(4);
361		ReentrantLock lock = new ReentrantLock();
362		ManagedLocker locker = new ManagedLocker(lock);
363	<	ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
363	>	ForkJoinTask<Integer> f = new LockingFibTask(20, locker, lock);
364		p.execute(f);
365	<	assertTrue(p.getPoolSize() >= 4);
414	<	int r = f.get();
415	<	assertTrue(r ==  832040);
365	>	assertEquals(6765, (int) f.get());
366		} finally {
367		p.shutdownNow(); // don't wait out shutdown
368		}
#	Line 422 | Line 372 | public class ForkJoinPoolTest extends JS
372		* pollSubmission returns unexecuted submitted task, if present
373		*/
374		public void testPollSubmission() {
375	<	SubFJP p = null;
375	>	final CountDownLatch done = new CountDownLatch(1);
376	>	SubFJP p = new SubFJP();
377		try {
378	<	p = new SubFJP();
379	<	ForkJoinTask a = p.submit(new MediumRunnable());
380	<	ForkJoinTask b = p.submit(new MediumRunnable());
430	<	ForkJoinTask c = p.submit(new MediumRunnable());
378	>	ForkJoinTask a = p.submit(awaiter(done));
379	>	ForkJoinTask b = p.submit(awaiter(done));
380	>	ForkJoinTask c = p.submit(awaiter(done));
381		ForkJoinTask r = p.pollSubmission();
382		assertTrue(r == a || r == b || r == c);
383		assertFalse(r.isDone());
384		} finally {
385	+	done.countDown();
386		joinPool(p);
387		}
388		}
#	Line 440 | Line 391 | public class ForkJoinPoolTest extends JS
391		* drainTasksTo transfers unexecuted submitted tasks, if present
392		*/
393		public void testDrainTasksTo() {
394	<	SubFJP p = null;
394	>	final CountDownLatch done = new CountDownLatch(1);
395	>	SubFJP p = new SubFJP();
396		try {
397	<	p = new SubFJP();
398	<	ForkJoinTask a = p.submit(new MediumRunnable());
399	<	ForkJoinTask b = p.submit(new MediumRunnable());
448	<	ForkJoinTask c = p.submit(new MediumRunnable());
397	>	ForkJoinTask a = p.submit(awaiter(done));
398	>	ForkJoinTask b = p.submit(awaiter(done));
399	>	ForkJoinTask c = p.submit(awaiter(done));
400		ArrayList<ForkJoinTask> al = new ArrayList();
401		p.drainTasksTo(al);
402		assertTrue(al.size() > 0);
#	Line 454 | Line 405 | public class ForkJoinPoolTest extends JS
405		assertFalse(r.isDone());
406		}
407		} finally {
408	+	done.countDown();
409		joinPool(p);
410		}
411		}
412
461	–
413		// FJ Versions of AbstractExecutorService tests
414
415		/**
#	Line 466 | Line 417 | public class ForkJoinPoolTest extends JS
417		*/
418		public void testExecuteRunnable() throws Throwable {
419		ExecutorService e = new ForkJoinPool(1);
420	<	TrackedShortRunnable task = new TrackedShortRunnable();
421	<	assertFalse(task.done);
422	<	Future<?> future = e.submit(task);
423	<	future.get();
424	<	assertTrue(task.done);
420	>	try {
421	>	final AtomicBoolean done = new AtomicBoolean(false);
422	>	CheckedRunnable task = new CheckedRunnable() {
423	>	public void realRun() {
424	>	done.set(true);
425	>	}};
426	>	Future<?> future = e.submit(task);
427	>	assertNull(future.get());
428	>	assertNull(future.get(0, MILLISECONDS));
429	>	assertTrue(done.get());
430	>	assertTrue(future.isDone());
431	>	assertFalse(future.isCancelled());
432	>	} finally {
433	>	joinPool(e);
434	>	}
435		}
436
476	–
437		/**
438		* Completed submit(callable) returns result
439		*/
440		public void testSubmitCallable() throws Throwable {
441		ExecutorService e = new ForkJoinPool(1);
442	<	Future<String> future = e.submit(new StringTask());
443	<	String result = future.get();
444	<	assertSame(TEST_STRING, result);
442	>	try {
443	>	Future<String> future = e.submit(new StringTask());
444	>	assertSame(TEST_STRING, future.get());
445	>	assertTrue(future.isDone());
446	>	assertFalse(future.isCancelled());
447	>	} finally {
448	>	joinPool(e);
449	>	}
450		}
451
452		/**
#	Line 489 | Line 454 | public class ForkJoinPoolTest extends JS
454		*/
455		public void testSubmitRunnable() throws Throwable {
456		ExecutorService e = new ForkJoinPool(1);
457	<	Future<?> future = e.submit(new NoOpRunnable());
458	<	future.get();
459	<	assertTrue(future.isDone());
457	>	try {
458	>	Future<?> future = e.submit(new NoOpRunnable());
459	>	assertNull(future.get());
460	>	assertTrue(future.isDone());
461	>	assertFalse(future.isCancelled());
462	>	} finally {
463	>	joinPool(e);
464	>	}
465		}
466
467		/**
#	Line 499 | Line 469 | public class ForkJoinPoolTest extends JS
469		*/
470		public void testSubmitRunnable2() throws Throwable {
471		ExecutorService e = new ForkJoinPool(1);
472	<	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
473	<	String result = future.get();
474	<	assertSame(TEST_STRING, result);
472	>	try {
473	>	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
474	>	assertSame(TEST_STRING, future.get());
475	>	assertTrue(future.isDone());
476	>	assertFalse(future.isCancelled());
477	>	} finally {
478	>	joinPool(e);
479	>	}
480		}
481
507	–
482		/**
483	<	* A submitted privileged action to completion
483	>	* A submitted privileged action runs to completion
484		*/
485	<	public void testSubmitPrivilegedAction() throws Throwable {
486	<	Policy savedPolicy = null;
487	<	try {
488	<	savedPolicy = Policy.getPolicy();
489	<	AdjustablePolicy policy = new AdjustablePolicy();
516	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
517	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
518	<	Policy.setPolicy(policy);
519	<	} catch (AccessControlException ok) {
520	<	return;
521	<	}
522	<	try {
485	>	public void testSubmitPrivilegedAction() throws Exception {
486	>	final Callable callable = Executors.callable(new PrivilegedAction() {
487	>	public Object run() { return TEST_STRING; }});
488	>	Runnable r = new CheckedRunnable() {
489	>	public void realRun() throws Exception {
490		ExecutorService e = new ForkJoinPool(1);
491	<	Future future = e.submit(Executors.callable(new PrivilegedAction() {
492	<	public Object run() {
493	<	return TEST_STRING;
494	<	}}));
491	>	try {
492	>	Future future = e.submit(callable);
493	>	assertSame(TEST_STRING, future.get());
494	>	} finally {
495	>	joinPool(e);
496	>	}
497	>	}};
498
499	<	Object result = future.get();
530	<	assertSame(TEST_STRING, result);
531	<	}
532	<	finally {
533	<	Policy.setPolicy(savedPolicy);
534	<	}
499	>	runWithPermissions(r, new RuntimePermission("modifyThread"));
500		}
501
502		/**
503	<	* A submitted a privileged exception action runs to completion
503	>	* A submitted privileged exception action runs to completion
504		*/
505	<	public void testSubmitPrivilegedExceptionAction() throws Throwable {
506	<	Policy savedPolicy = null;
507	<	try {
508	<	savedPolicy = Policy.getPolicy();
509	<	AdjustablePolicy policy = new AdjustablePolicy();
510	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
546	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
547	<	Policy.setPolicy(policy);
548	<	} catch (AccessControlException ok) {
549	<	return;
550	<	}
551	<
552	<	try {
505	>	public void testSubmitPrivilegedExceptionAction() throws Exception {
506	>	final Callable callable =
507	>	Executors.callable(new PrivilegedExceptionAction() {
508	>	public Object run() { return TEST_STRING; }});
509	>	Runnable r = new CheckedRunnable() {
510	>	public void realRun() throws Exception {
511		ExecutorService e = new ForkJoinPool(1);
512	<	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
513	<	public Object run() {
514	<	return TEST_STRING;
515	<	}}));
512	>	try {
513	>	Future future = e.submit(callable);
514	>	assertSame(TEST_STRING, future.get());
515	>	} finally {
516	>	joinPool(e);
517	>	}
518	>	}};
519
520	<	Object result = future.get();
560	<	assertSame(TEST_STRING, result);
561	<	}
562	<	finally {
563	<	Policy.setPolicy(savedPolicy);
564	<	}
520	>	runWithPermissions(r, new RuntimePermission("modifyThread"));
521		}
522
523		/**
524		* A submitted failed privileged exception action reports exception
525		*/
526	<	public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
527	<	Policy savedPolicy = null;
528	<	try {
529	<	savedPolicy = Policy.getPolicy();
530	<	AdjustablePolicy policy = new AdjustablePolicy();
531	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
576	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
577	<	Policy.setPolicy(policy);
578	<	} catch (AccessControlException ok) {
579	<	return;
580	<	}
581	<
582	<
583	<	try {
526	>	public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
527	>	final Callable callable =
528	>	Executors.callable(new PrivilegedExceptionAction() {
529	>	public Object run() { throw new IndexOutOfBoundsException(); }});
530	>	Runnable r = new CheckedRunnable() {
531	>	public void realRun() throws Exception {
532		ExecutorService e = new ForkJoinPool(1);
533	<	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
534	<	public Object run() throws Exception {
535	<	throw new IndexOutOfBoundsException();
536	<	}}));
533	>	try {
534	>	Future future = e.submit(callable);
535	>	try {
536	>	future.get();
537	>	shouldThrow();
538	>	} catch (ExecutionException success) {
539	>	assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
540	>	}
541	>	} finally {
542	>	joinPool(e);
543	>	}
544	>	}};
545
546	<	Object result = future.get();
591	<	shouldThrow();
592	<	} catch (ExecutionException success) {
593	<	assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
594	<	} finally {
595	<	Policy.setPolicy(savedPolicy);
596	<	}
546	>	runWithPermissions(r, new RuntimePermission("modifyThread"));
547		}
548
549		/**
550		* execute(null runnable) throws NullPointerException
551		*/
552		public void testExecuteNullRunnable() {
553	+	ExecutorService e = new ForkJoinPool(1);
554		try {
555	<	ExecutorService e = new ForkJoinPool(1);
605	<	TrackedShortRunnable task = null;
606	<	Future<?> future = e.submit(task);
555	>	Future<?> future = e.submit((Runnable) null);
556		shouldThrow();
557	<	} catch (NullPointerException success) {}
557	>	} catch (NullPointerException success) {
558	>	} finally {
559	>	joinPool(e);
560	>	}
561		}
562
611	–
563		/**
564		* submit(null callable) throws NullPointerException
565		*/
566		public void testSubmitNullCallable() {
567	+	ExecutorService e = new ForkJoinPool(1);
568		try {
569	<	ExecutorService e = new ForkJoinPool(1);
618	<	StringTask t = null;
619	<	Future<String> future = e.submit(t);
569	>	Future<String> future = e.submit((Callable) null);
570		shouldThrow();
571	<	} catch (NullPointerException success) {}
571	>	} catch (NullPointerException success) {
572	>	} finally {
573	>	joinPool(e);
574	>	}
575		}
576
624	–
577		/**
578	<	* Blocking on submit(callable) throws InterruptedException if
627	<	* caller interrupted.
578	>	* submit(callable).get() throws InterruptedException if interrupted
579		*/
580		public void testInterruptedSubmit() throws InterruptedException {
581	<	final ForkJoinPool p = new ForkJoinPool(1);
582	<
583	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
584	<	void realRun() throws Throwable {
585	<	p.submit(new CheckedCallable<Object>() {
586	<	public Object realCall() throws Throwable {
587	<	try {
588	<	Thread.sleep(MEDIUM_DELAY_MS);
589	<	} catch (InterruptedException ok) {
590	<	}
591	<	return null;
592	<	}}).get();
593	<	}});
594	<
595	<	t.start();
596	<	Thread.sleep(SHORT_DELAY_MS);
597	<	t.interrupt();
598	<	t.join();
599	<	p.shutdownNow();
600	<	joinPool(p);
581	>	final CountDownLatch submitted    = new CountDownLatch(1);
582	>	final CountDownLatch quittingTime = new CountDownLatch(1);
583	>	final ExecutorService p = new ForkJoinPool(1);
584	>	final Callable<Void> awaiter = new CheckedCallable<Void>() {
585	>	public Void realCall() throws InterruptedException {
586	>	assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS));
587	>	return null;
588	>	}};
589	>	try {
590	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
591	>	public void realRun() throws Exception {
592	>	Future<Void> future = p.submit(awaiter);
593	>	submitted.countDown();
594	>	future.get();
595	>	}});
596	>	t.start();
597	>	assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS));
598	>	t.interrupt();
599	>	t.join();
600	>	} finally {
601	>	quittingTime.countDown();
602	>	joinPool(p);
603	>	}
604		}
605
606		/**
#	Line 657 | Line 611 | public class ForkJoinPoolTest extends JS
611		ForkJoinPool p = new ForkJoinPool(1);
612		try {
613		p.submit(new Callable() {
614	<	public Object call() {
615	<	int i = 5/0;
662	<	return Boolean.TRUE;
663	<	}}).get();
614	>	public Object call() { throw new ArithmeticException(); }})
615	>	.get();
616		shouldThrow();
617		} catch (ExecutionException success) {
618		assertTrue(success.getCause() instanceof ArithmeticException);
619	+	} finally {
620	+	joinPool(p);
621		}
668	–
669	–	joinPool(p);
622		}
623
624		/**
#	Line 702 | Line 654 | public class ForkJoinPoolTest extends JS
654		*/
655		public void testInvokeAny3() throws Throwable {
656		ExecutorService e = new ForkJoinPool(1);
657	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
658	+	l.add(null);
659		try {
706	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
707	–	l.add(null);
660		e.invokeAny(l);
661		shouldThrow();
662		} catch (NullPointerException success) {
#	Line 717 | Line 669 | public class ForkJoinPoolTest extends JS
669		* invokeAny(c) throws NullPointerException if c has null elements
670		*/
671		public void testInvokeAny4() throws Throwable {
672	+	CountDownLatch latch = new CountDownLatch(1);
673		ExecutorService e = new ForkJoinPool(1);
674	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
675	+	l.add(latchAwaitingStringTask(latch));
676	+	l.add(null);
677		try {
722	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
723	–	l.add(new Callable<String>() {
724	–	public String call() {
725	–	// The delay gives the pool a chance to notice
726	–	// the null element.
727	–	sleepTillInterrupted(SMALL_DELAY_MS);
728	–	return "foo";
729	–	}});
730	–	l.add(null);
678		e.invokeAny(l);
679		shouldThrow();
680		} catch (NullPointerException success) {
681		} finally {
682	+	latch.countDown();
683		joinPool(e);
684		}
685		}
#	Line 741 | Line 689 | public class ForkJoinPoolTest extends JS
689		*/
690		public void testInvokeAny5() throws Throwable {
691		ExecutorService e = new ForkJoinPool(1);
692	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
693	+	l.add(new NPETask());
694		try {
745	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
746	–	l.add(new NPETask());
695		e.invokeAny(l);
696		shouldThrow();
697		} catch (ExecutionException success) {
#	Line 759 | Line 707 | public class ForkJoinPoolTest extends JS
707		public void testInvokeAny6() throws Throwable {
708		ExecutorService e = new ForkJoinPool(1);
709		try {
710	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
710	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
711		l.add(new StringTask());
712		l.add(new StringTask());
713		String result = e.invokeAny(l);
#	Line 802 | Line 750 | public class ForkJoinPoolTest extends JS
750		*/
751		public void testInvokeAll3() throws InterruptedException {
752		ExecutorService e = new ForkJoinPool(1);
753	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
754	+	l.add(new StringTask());
755	+	l.add(null);
756		try {
806	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
807	–	l.add(new StringTask());
808	–	l.add(null);
757		e.invokeAll(l);
758		shouldThrow();
759		} catch (NullPointerException success) {
#	Line 820 | Line 768 | public class ForkJoinPoolTest extends JS
768		*/
769		public void testInvokeAll4() throws Throwable {
770		ExecutorService e = new ForkJoinPool(1);
771	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
772	+	l.add(new NPETask());
773	+	List<Future<String>> futures = e.invokeAll(l);
774	+	assertEquals(1, futures.size());
775		try {
776	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
825	<	l.add(new NPETask());
826	<	List<Future<String>> result = e.invokeAll(l);
827	<	assertEquals(1, result.size());
828	<	for (Future<String> future : result)
829	<	future.get();
776	>	futures.get(0).get();
777		shouldThrow();
778		} catch (ExecutionException success) {
779		assertTrue(success.getCause() instanceof NullPointerException);
#	Line 841 | Line 788 | public class ForkJoinPoolTest extends JS
788		public void testInvokeAll5() throws Throwable {
789		ExecutorService e = new ForkJoinPool(1);
790		try {
791	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
791	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
792		l.add(new StringTask());
793		l.add(new StringTask());
794	<	List<Future<String>> result = e.invokeAll(l);
795	<	assertEquals(2, result.size());
796	<	for (Future<String> future : result)
794	>	List<Future<String>> futures = e.invokeAll(l);
795	>	assertEquals(2, futures.size());
796	>	for (Future<String> future : futures)
797		assertSame(TEST_STRING, future.get());
798		} finally {
799		joinPool(e);
800		}
801		}
802
856	–
803		/**
804		* timed invokeAny(null) throws NullPointerException
805		*/
#	Line 873 | Line 819 | public class ForkJoinPoolTest extends JS
819		*/
820		public void testTimedInvokeAnyNullTimeUnit() throws Throwable {
821		ExecutorService e = new ForkJoinPool(1);
822	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
823	+	l.add(new StringTask());
824		try {
877	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
878	–	l.add(new StringTask());
825		e.invokeAny(l, MEDIUM_DELAY_MS, null);
826		shouldThrow();
827		} catch (NullPointerException success) {
#	Line 903 | Line 849 | public class ForkJoinPoolTest extends JS
849		* timed invokeAny(c) throws NullPointerException if c has null elements
850		*/
851		public void testTimedInvokeAny3() throws Throwable {
852	+	CountDownLatch latch = new CountDownLatch(1);
853		ExecutorService e = new ForkJoinPool(1);
854	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
855	+	l.add(latchAwaitingStringTask(latch));
856	+	l.add(null);
857		try {
908	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
909	–	l.add(new StringTask());
910	–	l.add(null);
858		e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
859		shouldThrow();
860		} catch (NullPointerException success) {
861		} finally {
862	+	latch.countDown();
863		joinPool(e);
864		}
865		}
#	Line 921 | Line 869 | public class ForkJoinPoolTest extends JS
869		*/
870		public void testTimedInvokeAny4() throws Throwable {
871		ExecutorService e = new ForkJoinPool(1);
872	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
873	+	l.add(new NPETask());
874		try {
925	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
926	–	l.add(new NPETask());
875		e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
876		shouldThrow();
877		} catch (ExecutionException success) {
#	Line 939 | Line 887 | public class ForkJoinPoolTest extends JS
887		public void testTimedInvokeAny5() throws Throwable {
888		ExecutorService e = new ForkJoinPool(1);
889		try {
890	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
890	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
891		l.add(new StringTask());
892		l.add(new StringTask());
893		String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
#	Line 968 | Line 916 | public class ForkJoinPoolTest extends JS
916		*/
917		public void testTimedInvokeAllNullTimeUnit() throws Throwable {
918		ExecutorService e = new ForkJoinPool(1);
919	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
920	+	l.add(new StringTask());
921		try {
972	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
973	–	l.add(new StringTask());
922		e.invokeAll(l, MEDIUM_DELAY_MS, null);
923		shouldThrow();
924		} catch (NullPointerException success) {
#	Line 999 | Line 947 | public class ForkJoinPoolTest extends JS
947		*/
948		public void testTimedInvokeAll3() throws InterruptedException {
949		ExecutorService e = new ForkJoinPool(1);
950	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
951	+	l.add(new StringTask());
952	+	l.add(null);
953		try {
1003	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1004	–	l.add(new StringTask());
1005	–	l.add(null);
954		e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
955		shouldThrow();
956		} catch (NullPointerException success) {
#	Line 1016 | Line 964 | public class ForkJoinPoolTest extends JS
964		*/
965		public void testTimedInvokeAll4() throws Throwable {
966		ExecutorService e = new ForkJoinPool(1);
967	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
968	+	l.add(new NPETask());
969	+	List<Future<String>> futures
970	+	= e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
971	+	assertEquals(1, futures.size());
972		try {
973	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1021	<	l.add(new NPETask());
1022	<	List<Future<String>> result
1023	<	= e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1024	<	assertEquals(1, result.size());
1025	<	for (Future<String> future : result)
1026	<	future.get();
973	>	futures.get(0).get();
974		shouldThrow();
975		} catch (ExecutionException success) {
976		assertTrue(success.getCause() instanceof NullPointerException);
#	Line 1038 | Line 985 | public class ForkJoinPoolTest extends JS
985		public void testTimedInvokeAll5() throws Throwable {
986		ExecutorService e = new ForkJoinPool(1);
987		try {
988	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
988	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
989		l.add(new StringTask());
990		l.add(new StringTask());
991	<	List<Future<String>> result
991	>	List<Future<String>> futures
992		= e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
993	<	assertEquals(2, result.size());
994	<	for (Future<String> future : result)
993	>	assertEquals(2, futures.size());
994	>	for (Future<String> future : futures)
995		assertSame(TEST_STRING, future.get());
996		} finally {
997		joinPool(e);

Diff Legend

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