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.27 by jsr166, Fri Sep 17 01:04:10 2010 UTC vs.
Revision 1.43 by jsr166, Sun May 29 13:45:35 2011 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		import junit.framework.*;
#	Line 22 | Line 22 | 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.security.AccessControlException;
#	Line 164 | Line 165 | public class ForkJoinPoolTest extends JS
165		try {
166		assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
167		p.getFactory());
167	–	assertTrue(p.isQuiescent());
168		assertFalse(p.getAsyncMode());
169		assertEquals(0, p.getActiveThreadCount());
170		assertEquals(0, p.getStealCount());
#	Line 199 | Line 199 | public class ForkJoinPoolTest extends JS
199		} catch (NullPointerException success) {}
200		}
201
202	–
202		/**
203		* getParallelism returns size set in constructor
204		*/
#	Line 233 | Line 232 | public class ForkJoinPoolTest extends JS
232		* performs its defined action
233		*/
234		public void testSetUncaughtExceptionHandler() throws InterruptedException {
235	<	final CountDownLatch uncaughtExceptionHappened = new CountDownLatch(1);
235	>	final CountDownLatch uehInvoked = new CountDownLatch(1);
236		final Thread.UncaughtExceptionHandler eh =
237		new Thread.UncaughtExceptionHandler() {
238		public void uncaughtException(Thread t, Throwable e) {
239	<	uncaughtExceptionHappened.countDown();
239	>	uehInvoked.countDown();
240		}};
241		ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
242		eh, false);
243		try {
244		assertSame(eh, p.getUncaughtExceptionHandler());
245	<	p.execute(new FailingTask());
246	<	uncaughtExceptionHappened.await();
245	>	p.execute(new FibTask(8));
246	>	assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
247		} finally {
248	<	//p.shutdownNow();
248	>	p.shutdownNow(); // failure might have prevented processing task
249		joinPool(p);
250		}
251		}
252
253		/**
254	<	* After invoking a single task, isQuiescent is true,
255	<	* queues are empty, threads are not active, and
256	<	* construction parameters continue to hold
254	>	* After invoking a single task, isQuiescent eventually becomes
255	>	* true, at which time queues are empty, threads are not active,
256	>	* the task has completed successfully, and construction
257	>	* parameters continue to hold
258		*/
259	<	public void testisQuiescent() throws InterruptedException {
259	>	public void testIsQuiescent() throws Exception {
260		ForkJoinPool p = new ForkJoinPool(2);
261		try {
262	<	p.invoke(new FibTask(20));
262	>	assertTrue(p.isQuiescent());
263	>	long startTime = System.nanoTime();
264	>	FibTask f = new FibTask(20);
265	>	p.invoke(f);
266		assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
267		p.getFactory());
268	<	Thread.sleep(MEDIUM_DELAY_MS);
268	>	while (! p.isQuiescent()) {
269	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
270	>	throw new AssertionFailedError("timed out");
271	>	assertFalse(p.getAsyncMode());
272	>	assertFalse(p.isShutdown());
273	>	assertFalse(p.isTerminating());
274	>	assertFalse(p.isTerminated());
275	>	Thread.yield();
276	>	}
277	>
278		assertTrue(p.isQuiescent());
279		assertFalse(p.getAsyncMode());
280		assertEquals(0, p.getActiveThreadCount());
#	Line 272 | Line 284 | public class ForkJoinPoolTest extends JS
284		assertFalse(p.isShutdown());
285		assertFalse(p.isTerminating());
286		assertFalse(p.isTerminated());
287	+	assertTrue(f.isDone());
288	+	assertEquals(6765, (int) f.get());
289		} finally {
290		joinPool(p);
291		}
#	Line 315 | Line 329 | public class ForkJoinPoolTest extends JS
329		try {
330		ReentrantLock lock = new ReentrantLock();
331		ManagedLocker locker = new ManagedLocker(lock);
332	<	ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
332	>	ForkJoinTask<Integer> f = new LockingFibTask(20, locker, lock);
333		p.execute(f);
334	<	assertEquals(832040, (int) f.get());
334	>	assertEquals(6765, (int) f.get());
335		} finally {
336		p.shutdownNow(); // don't wait out shutdown
337		}
#	Line 327 | Line 341 | public class ForkJoinPoolTest extends JS
341		* pollSubmission returns unexecuted submitted task, if present
342		*/
343		public void testPollSubmission() {
344	+	final CountDownLatch done = new CountDownLatch(1);
345		SubFJP p = new SubFJP();
346		try {
347	<	ForkJoinTask a = p.submit(new MediumRunnable());
348	<	ForkJoinTask b = p.submit(new MediumRunnable());
349	<	ForkJoinTask c = p.submit(new MediumRunnable());
347	>	ForkJoinTask a = p.submit(awaiter(done));
348	>	ForkJoinTask b = p.submit(awaiter(done));
349	>	ForkJoinTask c = p.submit(awaiter(done));
350		ForkJoinTask r = p.pollSubmission();
351		assertTrue(r == a || r == b || r == c);
352		assertFalse(r.isDone());
353		} finally {
354	+	done.countDown();
355		joinPool(p);
356		}
357		}
#	Line 344 | Line 360 | public class ForkJoinPoolTest extends JS
360		* drainTasksTo transfers unexecuted submitted tasks, if present
361		*/
362		public void testDrainTasksTo() {
363	+	final CountDownLatch done = new CountDownLatch(1);
364		SubFJP p = new SubFJP();
365		try {
366	<	ForkJoinTask a = p.submit(new MediumRunnable());
367	<	ForkJoinTask b = p.submit(new MediumRunnable());
368	<	ForkJoinTask c = p.submit(new MediumRunnable());
366	>	ForkJoinTask a = p.submit(awaiter(done));
367	>	ForkJoinTask b = p.submit(awaiter(done));
368	>	ForkJoinTask c = p.submit(awaiter(done));
369		ArrayList<ForkJoinTask> al = new ArrayList();
370		p.drainTasksTo(al);
371		assertTrue(al.size() > 0);
#	Line 357 | Line 374 | public class ForkJoinPoolTest extends JS
374		assertFalse(r.isDone());
375		}
376		} finally {
377	+	done.countDown();
378		joinPool(p);
379		}
380		}
381
364	–
382		// FJ Versions of AbstractExecutorService tests
383
384		/**
#	Line 370 | Line 387 | public class ForkJoinPoolTest extends JS
387		public void testExecuteRunnable() throws Throwable {
388		ExecutorService e = new ForkJoinPool(1);
389		try {
390	<	TrackedShortRunnable task = new TrackedShortRunnable();
391	<	assertFalse(task.done);
390	>	final AtomicBoolean done = new AtomicBoolean(false);
391	>	CheckedRunnable task = new CheckedRunnable() {
392	>	public void realRun() {
393	>	done.set(true);
394	>	}};
395		Future<?> future = e.submit(task);
396	<	future.get();
397	<	assertTrue(task.done);
396	>	assertNull(future.get());
397	>	assertNull(future.get(0, MILLISECONDS));
398	>	assertTrue(done.get());
399	>	assertTrue(future.isDone());
400	>	assertFalse(future.isCancelled());
401		} finally {
402		joinPool(e);
403		}
404		}
405
383	–
406		/**
407		* Completed submit(callable) returns result
408		*/
#	Line 388 | Line 410 | public class ForkJoinPoolTest extends JS
410		ExecutorService e = new ForkJoinPool(1);
411		try {
412		Future<String> future = e.submit(new StringTask());
413	<	String result = future.get();
414	<	assertSame(TEST_STRING, result);
413	>	assertSame(TEST_STRING, future.get());
414	>	assertTrue(future.isDone());
415	>	assertFalse(future.isCancelled());
416		} finally {
417		joinPool(e);
418		}
#	Line 402 | Line 425 | public class ForkJoinPoolTest extends JS
425		ExecutorService e = new ForkJoinPool(1);
426		try {
427		Future<?> future = e.submit(new NoOpRunnable());
428	<	future.get();
428	>	assertNull(future.get());
429		assertTrue(future.isDone());
430	+	assertFalse(future.isCancelled());
431		} finally {
432		joinPool(e);
433		}
#	Line 416 | Line 440 | public class ForkJoinPoolTest extends JS
440		ExecutorService e = new ForkJoinPool(1);
441		try {
442		Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
443	<	String result = future.get();
444	<	assertSame(TEST_STRING, result);
443	>	assertSame(TEST_STRING, future.get());
444	>	assertTrue(future.isDone());
445	>	assertFalse(future.isCancelled());
446		} finally {
447		joinPool(e);
448		}
449		}
450
426	–
451		/**
452	<	* A submitted privileged action to completion
452	>	* A submitted privileged action runs to completion
453		*/
454	<	public void testSubmitPrivilegedAction() throws Throwable {
455	<	Policy savedPolicy = null;
456	<	try {
457	<	savedPolicy = Policy.getPolicy();
434	<	AdjustablePolicy policy = new AdjustablePolicy();
435	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
436	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
437	<	Policy.setPolicy(policy);
438	<	} catch (AccessControlException ok) {
439	<	return;
440	<	}
441	<
442	<	try {
443	<	ExecutorService e = new ForkJoinPool(1);
444	<	try {
454	>	public void testSubmitPrivilegedAction() throws Exception {
455	>	Runnable r = new CheckedRunnable() {
456	>	public void realRun() throws Exception {
457	>	ExecutorService e = new ForkJoinPool(1);
458		Future future = e.submit(Executors.callable(new PrivilegedAction() {
459		public Object run() {
460		return TEST_STRING;
461		}}));
462
463	<	Object result = future.get();
464	<	assertSame(TEST_STRING, result);
465	<	} finally {
466	<	joinPool(e);
467	<	}
455	<	} finally {
456	<	Policy.setPolicy(savedPolicy);
457	<	}
463	>	assertSame(TEST_STRING, future.get());
464	>	}};
465	>
466	>	runWithPermissions(r,
467	>	new RuntimePermission("modifyThread"));
468		}
469
470		/**
471	<	* A submitted a privileged exception action runs to completion
471	>	* A submitted privileged exception action runs to completion
472		*/
473	<	public void testSubmitPrivilegedExceptionAction() throws Throwable {
474	<	Policy savedPolicy = null;
475	<	try {
476	<	savedPolicy = Policy.getPolicy();
467	<	AdjustablePolicy policy = new AdjustablePolicy();
468	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
469	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
470	<	Policy.setPolicy(policy);
471	<	} catch (AccessControlException ok) {
472	<	return;
473	<	}
474	<
475	<	try {
476	<	ExecutorService e = new ForkJoinPool(1);
477	<	try {
473	>	public void testSubmitPrivilegedExceptionAction() throws Exception {
474	>	Runnable r = new CheckedRunnable() {
475	>	public void realRun() throws Exception {
476	>	ExecutorService e = new ForkJoinPool(1);
477		Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
478		public Object run() {
479		return TEST_STRING;
480		}}));
481
482	<	Object result = future.get();
483	<	assertSame(TEST_STRING, result);
484	<	} finally {
485	<	joinPool(e);
487	<	}
488	<	} finally {
489	<	Policy.setPolicy(savedPolicy);
490	<	}
482	>	assertSame(TEST_STRING, future.get());
483	>	}};
484	>
485	>	runWithPermissions(r, new RuntimePermission("modifyThread"));
486		}
487
488		/**
489		* A submitted failed privileged exception action reports exception
490		*/
491	<	public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
492	<	Policy savedPolicy = null;
493	<	try {
494	<	savedPolicy = Policy.getPolicy();
500	<	AdjustablePolicy policy = new AdjustablePolicy();
501	<	policy.addPermission(new RuntimePermission("getContextClassLoader"));
502	<	policy.addPermission(new RuntimePermission("setContextClassLoader"));
503	<	Policy.setPolicy(policy);
504	<	} catch (AccessControlException ok) {
505	<	return;
506	<	}
507	<
508	<	try {
509	<	ExecutorService e = new ForkJoinPool(1);
510	<	try {
491	>	public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
492	>	Runnable r = new CheckedRunnable() {
493	>	public void realRun() throws Exception {
494	>	ExecutorService e = new ForkJoinPool(1);
495		Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
496		public Object run() throws Exception {
497		throw new IndexOutOfBoundsException();
498		}}));
499
500	<	Object result = future.get();
501	<	shouldThrow();
502	<	} catch (ExecutionException success) {
503	<	assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
504	<	} finally {
505	<	joinPool(e);
506	<	}
507	<	} finally {
524	<	Policy.setPolicy(savedPolicy);
525	<	}
500	>	try {
501	>	future.get();
502	>	shouldThrow();
503	>	} catch (ExecutionException success) {
504	>	assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
505	>	}}};
506	>
507	>	runWithPermissions(r, new RuntimePermission("modifyThread"));
508		}
509
510		/**
#	Line 530 | Line 512 | public class ForkJoinPoolTest extends JS
512		*/
513		public void testExecuteNullRunnable() {
514		ExecutorService e = new ForkJoinPool(1);
533	–	TrackedShortRunnable task = null;
515		try {
516	<	Future<?> future = e.submit(task);
516	>	Future<?> future = e.submit((Runnable) null);
517		shouldThrow();
518		} catch (NullPointerException success) {
519		} finally {
#	Line 540 | Line 521 | public class ForkJoinPoolTest extends JS
521		}
522		}
523
543	–
524		/**
525		* submit(null callable) throws NullPointerException
526		*/
527		public void testSubmitNullCallable() {
528		ExecutorService e = new ForkJoinPool(1);
549	–	StringTask t = null;
529		try {
530	<	Future<String> future = e.submit(t);
530	>	Future<String> future = e.submit((Callable) null);
531		shouldThrow();
532		} catch (NullPointerException success) {
533		} finally {
#	Line 556 | Line 535 | public class ForkJoinPoolTest extends JS
535		}
536		}
537
559	–
538		/**
539		* submit(callable).get() throws InterruptedException if interrupted
540		*/
#	Line 785 | Line 763 | public class ForkJoinPoolTest extends JS
763		}
764		}
765
788	–
766		/**
767		* timed invokeAny(null) throws NullPointerException
768		*/

Diff Legend

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