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.1 by dl, Fri Jul 31 23:02:49 2009 UTC vs.
Revision 1.19 by dl, Sun Feb 28 13:35:22 2010 UTC

#	Line 8 | Line 8
8		import junit.framework.*;
9		import java.util.*;
10		import java.util.concurrent.*;
11	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
12		import java.util.concurrent.locks.*;
13		import java.security.*;
14
15	<	public class ForkJoinPoolTest extends JSR166TestCase{
15	>	public class ForkJoinPoolTest extends JSR166TestCase {
16		public static void main(String[] args) {
17		junit.textui.TestRunner.run (suite());
18		}
#	Line 25 | Line 26 | public class ForkJoinPoolTest extends JS
26		* 1. shutdown and related methods are tested via super.joinPool.
27		*
28		* 2. newTaskFor and adapters are tested in submit/invoke tests
29	<	*
29	>	*
30		* 3. We cannot portably test monitoring methods such as
31		* getStealCount() since they rely ultimately on random task
32		* stealing that may cause tasks not to be stolen/propagated
33		* across threads, especially on uniprocessors.
34	<	*
34	>	*
35		* 4. There are no independently testable ForkJoinWorkerThread
36		* methods, but they are covered here and in task tests.
37		*/
#	Line 50 | Line 51 | public class ForkJoinPoolTest extends JS
51		protected void onStart() { throw new Error(); }
52		}
53
54	<	static class FailingThreadFactory implements ForkJoinPool.ForkJoinWorkerThreadFactory {
54	>	static class FailingThreadFactory
55	>	implements ForkJoinPool.ForkJoinWorkerThreadFactory {
56		int calls = 0;
57	<	public ForkJoinWorkerThread newThread(ForkJoinPool p){
57	>	public ForkJoinWorkerThread newThread(ForkJoinPool p) {
58		if (++calls > 1) return null;
59		return new FailingFJWSubclass(p);
60	<	}
60	>	}
61		}
62
63	<	static class SubFJP extends ForkJoinPool { // to expose protected
63	>	static class SubFJP extends ForkJoinPool { // to expose protected
64		SubFJP() { super(1); }
65		public int drainTasksTo(Collection<? super ForkJoinTask<?>> c) {
66		return super.drainTasksTo(c);
#	Line 83 | Line 85 | public class ForkJoinPoolTest extends JS
85		}
86
87		// A simple recursive task for testing
88	<	static final class FibTask extends RecursiveTask<Integer> {
88	>	static final class FibTask extends RecursiveTask<Integer> {
89		final int number;
90		FibTask(int n) { number = n; }
91		public Integer compute() {
#	Line 97 | Line 99 | public class ForkJoinPoolTest extends JS
99		}
100
101		// A failing task for testing
102	<	static final class FailingTask extends ForkJoinTask<Void> {
102	>	static final class FailingTask extends ForkJoinTask<Void> {
103		public final Void getRawResult() { return null; }
104		protected final void setRawResult(Void mustBeNull) { }
105		protected final boolean exec() { throw new Error(); }
#	Line 105 | Line 107 | public class ForkJoinPoolTest extends JS
107		}
108
109		// Fib needlessly using locking to test ManagedBlockers
110	<	static final class LockingFibTask extends RecursiveTask<Integer> {
110	>	static final class LockingFibTask extends RecursiveTask<Integer> {
111		final int number;
112		final ManagedLocker locker;
113		final ReentrantLock lock;
114	<	LockingFibTask(int n, ManagedLocker locker, ReentrantLock lock) {
115	<	number = n;
114	>	LockingFibTask(int n, ManagedLocker locker, ReentrantLock lock) {
115	>	number = n;
116		this.locker = locker;
117		this.lock = lock;
118		}
#	Line 119 | Line 121 | public class ForkJoinPoolTest extends JS
121		LockingFibTask f1 = null;
122		LockingFibTask f2 = null;
123		locker.block();
124	<	n = number;
124	>	n = number;
125		if (n > 1) {
126		f1 = new LockingFibTask(n - 1, locker, lock);
127		f2 = new LockingFibTask(n - 2, locker, lock);
#	Line 134 | Line 136 | public class ForkJoinPoolTest extends JS
136		}
137		}
138
139	<	/**
140	<	* Succesfully constructed pool reports default factory,
139	>	/**
140	>	* Successfully constructed pool reports default factory,
141		* parallelism and async mode policies, no active threads or
142		* tasks, and quiescent running state.
143		*/
#	Line 143 | Line 145 | public class ForkJoinPoolTest extends JS
145		ForkJoinPool p = null;
146		try {
147		p = new ForkJoinPool(1);
148	<	assertTrue(p.getFactory() == ForkJoinPool.defaultForkJoinWorkerThreadFactory);
148	>	assertTrue(p.getFactory() ==
149	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory);
150		assertTrue(p.isQuiescent());
151		assertTrue(p.getMaintainsParallelism());
152		assertFalse(p.getAsyncMode());
#	Line 160 | Line 163 | public class ForkJoinPoolTest extends JS
163		}
164		}
165
166	<	/**
167	<	* Constructor throws if size argument is less than zero
166	>	/**
167	>	* Constructor throws if size argument is less than zero
168		*/
169		public void testConstructor1() {
170		try {
171		new ForkJoinPool(-1);
172		shouldThrow();
173	<	}
171	<	catch (IllegalArgumentException success){}
173	>	} catch (IllegalArgumentException success) {}
174		}
175
176	<	/**
177	<	* Constructor throws if factory argument is null
176	>	/**
177	>	* Constructor throws if factory argument is null
178		*/
179		public void testConstructor2() {
180		try {
181		new ForkJoinPool(1, null);
182		shouldThrow();
183	<	}
182	<	catch (NullPointerException success){}
183	>	} catch (NullPointerException success) {}
184		}
185
186
187	<	/**
188	<	* getParallelism returns size set in constructor
187	>	/**
188	>	* getParallelism returns size set in constructor
189		*/
190		public void testGetParallelism() {
191		ForkJoinPool p = null;
#	Line 196 | Line 197 | public class ForkJoinPoolTest extends JS
197		}
198		}
199
200	<	/**
200	>	/**
201		* setParallelism changes reported parallelism level.
202		*/
203		public void testSetParallelism() {
#	Line 211 | Line 212 | public class ForkJoinPoolTest extends JS
212		}
213		}
214
215	<	/**
215	>	/**
216		* setParallelism with argument <= 0 throws exception
217		*/
218		public void testSetParallelism2() {
#	Line 221 | Line 222 | public class ForkJoinPoolTest extends JS
222		assertTrue(p.getParallelism() == 1);
223		p.setParallelism(-2);
224		shouldThrow();
225	<	}catch (IllegalArgumentException success){
225	>	} catch (IllegalArgumentException success) {
226		} finally {
227		joinPool(p);
228		}
229		}
230
231	<	/**
231	>	/**
232		* getPoolSize returns number of started workers.
233		*/
234		public void testGetPoolSize() {
235		ForkJoinPool p = null;
236		try {
237		p = new ForkJoinPool(1);
238	<	assertTrue(p.getPoolSize() == 0);
238	>	assertTrue(p.getActiveThreadCount() == 0);
239		Future<String> future = p.submit(new StringTask());
240		assertTrue(p.getPoolSize() == 1);
241
#	Line 243 | Line 244 | public class ForkJoinPoolTest extends JS
244		}
245		}
246
247	<	/**
247	>	/**
248		* setMaximumPoolSize changes size reported by getMaximumPoolSize.
249		*/
250		public void testSetMaximumPoolSize() {
#	Line 257 | Line 258 | public class ForkJoinPoolTest extends JS
258		}
259		}
260
261	<	/**
261	>	/**
262		* setMaximumPoolSize with argument <= 0 throws exception
263		*/
264		public void testSetMaximumPoolSize2() {
#	Line 266 | Line 267 | public class ForkJoinPoolTest extends JS
267		p = new ForkJoinPool(1);
268		p.setMaximumPoolSize(-2);
269		shouldThrow();
270	<	}catch (IllegalArgumentException success){
270	>	} catch (IllegalArgumentException success) {
271		} finally {
272		joinPool(p);
273		}
274		}
275
276	<	/**
276	>	/**
277		* setMaintainsParallelism changes policy reported by
278		* getMaintainsParallelism.
279		*/
#	Line 286 | Line 287 | public class ForkJoinPoolTest extends JS
287		joinPool(p);
288		}
289		}
290	<
291	<	/**
290	>
291	>	/**
292		* setAsyncMode changes policy reported by
293		* getAsyncMode.
294		*/
#	Line 302 | Line 303 | public class ForkJoinPoolTest extends JS
303		}
304		}
305
306	<	/**
306	>	/**
307		* setUncaughtExceptionHandler changes handler for uncaught exceptions.
308		*
309		* Additionally tests: Overriding ForkJoinWorkerThread.onStart
310		* performs its defined action
311		*/
312	<	public void testSetUncaughtExceptionHandler() {
312	>	public void testSetUncaughtExceptionHandler() throws InterruptedException {
313		ForkJoinPool p = null;
314		try {
315		p = new ForkJoinPool(1, new FailingThreadFactory());
#	Line 318 | Line 319 | public class ForkJoinPoolTest extends JS
319		p.execute(new FailingTask());
320		Thread.sleep(MEDIUM_DELAY_MS);
321		assertTrue(eh.catches > 0);
321	–	} catch(InterruptedException e){
322	–	unexpectedException();
322		} finally {
323	+	p.shutdownNow();
324		joinPool(p);
325		}
326		}
327
328	<	/**
328	>	/**
329		* setUncaughtExceptionHandler of null removes handler
330		*/
331		public void testSetUncaughtExceptionHandler2() {
#	Line 340 | Line 340 | public class ForkJoinPoolTest extends JS
340		}
341
342
343	<	/**
343	>	/**
344		* After invoking a single task, isQuiescent is true,
345		* queues are empty, threads are not active, and
346		* construction parameters continue to hold
347		*/
348	<	public void testisQuiescent() {
348	>	public void testisQuiescent() throws InterruptedException {
349		ForkJoinPool p = null;
350		try {
351		p = new ForkJoinPool(2);
352		p.invoke(new FibTask(20));
353	<	assertTrue(p.getFactory() == ForkJoinPool.defaultForkJoinWorkerThreadFactory);
353	>	assertTrue(p.getFactory() ==
354	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory);
355		Thread.sleep(MEDIUM_DELAY_MS);
356		assertTrue(p.isQuiescent());
357		assertTrue(p.getMaintainsParallelism());
#	Line 362 | Line 363 | public class ForkJoinPoolTest extends JS
363		assertFalse(p.isShutdown());
364		assertFalse(p.isTerminating());
365		assertFalse(p.isTerminated());
365	–	} catch(InterruptedException e){
366	–	unexpectedException();
366		} finally {
367		joinPool(p);
368		}
#	Line 372 | Line 371 | public class ForkJoinPoolTest extends JS
371		/**
372		* Completed submit(ForkJoinTask) returns result
373		*/
374	<	public void testSubmitForkJoinTask() {
374	>	public void testSubmitForkJoinTask() throws Throwable {
375		ForkJoinPool p = null;
376		try {
377		p = new ForkJoinPool(1);
378		ForkJoinTask<Integer> f = p.submit(new FibTask(8));
379		int r = f.get();
380		assertTrue(r == 21);
382	–	} catch (ExecutionException ex) {
383	–	unexpectedException();
384	–	} catch (InterruptedException ex) {
385	–	unexpectedException();
381		} finally {
382		joinPool(p);
383		}
#	Line 408 | Line 403 | public class ForkJoinPoolTest extends JS
403		/**
404		* Pool maintains parallelism when using ManagedBlocker
405		*/
406	<	public void testBlockingForkJoinTask() {
406	>	public void testBlockingForkJoinTask() throws Throwable {
407		ForkJoinPool p = null;
408		try {
409		p = new ForkJoinPool(4);
#	Line 418 | Line 413 | public class ForkJoinPoolTest extends JS
413		p.execute(f);
414		assertTrue(p.getPoolSize() >= 4);
415		int r = f.get();
416	<	assertTrue(r ==  832040);
422	<	} catch (ExecutionException ex) {
423	<	unexpectedException();
424	<	} catch (InterruptedException ex) {
425	<	unexpectedException();
416	>	assertTrue(r == 832040);
417		} finally {
418	<	joinPool(p);
418	>	p.shutdownNow(); // don't wait out shutdown
419		}
420		}
421
#	Line 468 | Line 459 | public class ForkJoinPoolTest extends JS
459		}
460		}
461
462	<
462	>
463		// FJ Versions of AbstractExecutorService tests
464
465		/**
466		* execute(runnable) runs it to completion
467		*/
468	<	public void testExecuteRunnable() {
469	<	try {
470	<	ExecutorService e = new ForkJoinPool(1);
471	<	TrackedShortRunnable task = new TrackedShortRunnable();
472	<	assertFalse(task.done);
473	<	Future<?> future = e.submit(task);
474	<	future.get();
484	<	assertTrue(task.done);
485	<	}
486	<	catch (ExecutionException ex) {
487	<	unexpectedException();
488	<	}
489	<	catch (InterruptedException ex) {
490	<	unexpectedException();
491	<	}
468	>	public void testExecuteRunnable() throws Throwable {
469	>	ExecutorService e = new ForkJoinPool(1);
470	>	TrackedShortRunnable task = new TrackedShortRunnable();
471	>	assertFalse(task.done);
472	>	Future<?> future = e.submit(task);
473	>	future.get();
474	>	assertTrue(task.done);
475		}
476
477
478		/**
479		* Completed submit(callable) returns result
480		*/
481	<	public void testSubmitCallable() {
482	<	try {
483	<	ExecutorService e = new ForkJoinPool(1);
484	<	Future<String> future = e.submit(new StringTask());
485	<	String result = future.get();
503	<	assertSame(TEST_STRING, result);
504	<	}
505	<	catch (ExecutionException ex) {
506	<	unexpectedException();
507	<	}
508	<	catch (InterruptedException ex) {
509	<	unexpectedException();
510	<	}
481	>	public void testSubmitCallable() throws Throwable {
482	>	ExecutorService e = new ForkJoinPool(1);
483	>	Future<String> future = e.submit(new StringTask());
484	>	String result = future.get();
485	>	assertSame(TEST_STRING, result);
486		}
487
488		/**
489		* Completed submit(runnable) returns successfully
490		*/
491	<	public void testSubmitRunnable() {
492	<	try {
493	<	ExecutorService e = new ForkJoinPool(1);
494	<	Future<?> future = e.submit(new NoOpRunnable());
495	<	future.get();
521	<	assertTrue(future.isDone());
522	<	}
523	<	catch (ExecutionException ex) {
524	<	unexpectedException();
525	<	}
526	<	catch (InterruptedException ex) {
527	<	unexpectedException();
528	<	}
491	>	public void testSubmitRunnable() throws Throwable {
492	>	ExecutorService e = new ForkJoinPool(1);
493	>	Future<?> future = e.submit(new NoOpRunnable());
494	>	future.get();
495	>	assertTrue(future.isDone());
496		}
497
498		/**
499		* Completed submit(runnable, result) returns result
500		*/
501	<	public void testSubmitRunnable2() {
502	<	try {
503	<	ExecutorService e = new ForkJoinPool(1);
504	<	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
505	<	String result = future.get();
539	<	assertSame(TEST_STRING, result);
540	<	}
541	<	catch (ExecutionException ex) {
542	<	unexpectedException();
543	<	}
544	<	catch (InterruptedException ex) {
545	<	unexpectedException();
546	<	}
501	>	public void testSubmitRunnable2() throws Throwable {
502	>	ExecutorService e = new ForkJoinPool(1);
503	>	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
504	>	String result = future.get();
505	>	assertSame(TEST_STRING, result);
506		}
507
549	–
508		/**
509	<	* A submitted privileged action to completion
509	>	* A submitted privileged action runs to completion
510		*/
511	<	public void testSubmitPrivilegedAction() {
512	<	Policy savedPolicy = null;
513	<	try {
514	<	savedPolicy = Policy.getPolicy();
515	<	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() {
511	>	public void testSubmitPrivilegedAction() throws Throwable {
512	>	Runnable r = new CheckedRunnable() {
513	>	public void realRun() throws Exception {
514	>	ExecutorService e = new ForkJoinPool(1);
515	>	Future future = e.submit(Executors.callable(new PrivilegedAction() {
516		public Object run() {
517		return TEST_STRING;
518		}}));
519
520	<	Object result = future.get();
521	<	assertSame(TEST_STRING, result);
522	<	}
523	<	catch (ExecutionException ex) {
524	<	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	<	}
520	>	Object result = future.get();
521	>	assertSame(TEST_STRING, result);
522	>	}};
523	>
524	>	runWithPermissions(r, new RuntimePermission("modifyThread"));
525		}
526
527		/**
528	<	* A submitted a privileged exception action runs to completion
528	>	* A submitted privileged exception action runs to completion
529		*/
530	<	public void testSubmitPrivilegedExceptionAction() {
531	<	Policy savedPolicy = null;
532	<	try {
533	<	savedPolicy = Policy.getPolicy();
534	<	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() {
530	>	public void testSubmitPrivilegedExceptionAction() throws Throwable {
531	>	Runnable r = new CheckedRunnable() {
532	>	public void realRun() throws Exception {
533	>	ExecutorService e = new ForkJoinPool(1);
534	>	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
535		public Object run() {
536		return TEST_STRING;
537		}}));
538
539	<	Object result = future.get();
540	<	assertSame(TEST_STRING, result);
541	<	}
542	<	catch (ExecutionException ex) {
543	<	unexpectedException();
616	<	}
617	<	catch (InterruptedException ex) {
618	<	unexpectedException();
619	<	}
620	<	finally {
621	<	Policy.setPolicy(savedPolicy);
622	<	}
539	>	Object result = future.get();
540	>	assertSame(TEST_STRING, result);
541	>	}};
542	>
543	>	runWithPermissions(r, new RuntimePermission("modifyThread"));
544		}
545
546		/**
547		* A submitted failed privileged exception action reports exception
548		*/
549	<	public void testSubmitFailedPrivilegedExceptionAction() {
550	<	Policy savedPolicy = null;
551	<	try {
552	<	savedPolicy = Policy.getPolicy();
553	<	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() {
549	>	public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
550	>	Runnable r = new CheckedRunnable() {
551	>	public void realRun() throws Exception {
552	>	ExecutorService e = new ForkJoinPool(1);
553	>	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
554		public Object run() throws Exception {
555		throw new IndexOutOfBoundsException();
556		}}));
557
558	<	Object result = future.get();
559	<	shouldThrow();
560	<	}
561	<	catch (ExecutionException success) {
562	<	} catch (CancellationException success) {
563	<	} catch (InterruptedException ex) {
564	<	unexpectedException();
565	<	}
656	<	finally {
657	<	Policy.setPolicy(savedPolicy);
658	<	}
558	>	try {
559	>	Object result = future.get();
560	>	shouldThrow();
561	>	} catch (ExecutionException success) {
562	>	assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
563	>	}}};
564	>
565	>	runWithPermissions(r, new RuntimePermission("modifyThread"));
566		}
567
568		/**
569	<	* execute(null runnable) throws NPE
569	>	* execute(null runnable) throws NullPointerException
570		*/
571		public void testExecuteNullRunnable() {
572		try {
#	Line 667 | Line 574 | public class ForkJoinPoolTest extends JS
574		TrackedShortRunnable task = null;
575		Future<?> future = e.submit(task);
576		shouldThrow();
577	<	}
671	<	catch (NullPointerException success) {
672	<	}
673	<	catch (Exception ex) {
674	<	unexpectedException();
675	<	}
577	>	} catch (NullPointerException success) {}
578		}
579
580
581		/**
582	<	* submit(null callable) throws NPE
582	>	* submit(null callable) throws NullPointerException
583		*/
584		public void testSubmitNullCallable() {
585		try {
#	Line 685 | Line 587 | public class ForkJoinPoolTest extends JS
587		StringTask t = null;
588		Future<String> future = e.submit(t);
589		shouldThrow();
590	<	}
689	<	catch (NullPointerException success) {
690	<	}
691	<	catch (Exception ex) {
692	<	unexpectedException();
693	<	}
590	>	} catch (NullPointerException success) {}
591		}
592
593
594		/**
595	<	*  Blocking on submit(callable) throws InterruptedException if
596	<	*  caller interrupted.
595	>	* Blocking on submit(callable) throws InterruptedException if
596	>	* caller interrupted.
597		*/
598	<	public void testInterruptedSubmit() {
598	>	public void testInterruptedSubmit() throws InterruptedException {
599		final ForkJoinPool p = new ForkJoinPool(1);
600	<	Thread t = new Thread(new Runnable() {
601	<	public void run() {
602	<	try {
603	<	p.submit(new Callable<Object>() {
604	<	public Object call() {
605	<	try {
606	<	Thread.sleep(MEDIUM_DELAY_MS);
607	<	shouldThrow();
608	<	} catch(InterruptedException e){
609	<	}
610	<	return null;
611	<	}
612	<	}).get();
613	<	} catch(InterruptedException success){
614	<	} catch(Exception e) {
615	<	unexpectedException();
616	<	}
617	<
721	<	}
722	<	});
723	<	try {
724	<	t.start();
725	<	Thread.sleep(SHORT_DELAY_MS);
726	<	t.interrupt();
727	<	} catch(Exception e){
728	<	unexpectedException();
729	<	}
600	>
601	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
602	>	public void realRun() throws Throwable {
603	>	p.submit(new CheckedCallable<Object>() {
604	>	public Object realCall() throws Throwable {
605	>	try {
606	>	Thread.sleep(MEDIUM_DELAY_MS);
607	>	} catch (InterruptedException ok) {
608	>	}
609	>	return null;
610	>	}}).get();
611	>	}});
612	>
613	>	t.start();
614	>	Thread.sleep(SHORT_DELAY_MS);
615	>	t.interrupt();
616	>	t.join();
617	>	p.shutdownNow();
618		joinPool(p);
619		}
620
621		/**
622	<	*  get of submit(callable) throws ExecutionException if callable
623	<	*  throws exception
622	>	* get of submit(callable) throws ExecutionException if callable
623	>	* throws exception
624		*/
625	<	public void testSubmitEE() {
625	>	public void testSubmitEE() throws Throwable {
626		ForkJoinPool p = new ForkJoinPool(1);
739	–
627		try {
628	<	Callable c = new Callable() {
629	<	public Object call() {
630	<	int i = 5/0;
631	<	return Boolean.TRUE;
632	<	}
746	<	};
747	<
748	<	for(int i =0; i < 5; i++){
749	<	p.submit(c).get();
750	<	}
751	<
628	>	p.submit(new Callable() {
629	>	public Object call() {
630	>	int i = 5/0;
631	>	return Boolean.TRUE;
632	>	}}).get();
633		shouldThrow();
634	+	} catch (ExecutionException success) {
635	+	assertTrue(success.getCause() instanceof ArithmeticException);
636		}
637	<	catch(ExecutionException success){
755	<	} catch (CancellationException success) {
756	<	} catch(Exception e) {
757	<	unexpectedException();
758	<	}
637	>
638		joinPool(p);
639		}
640
641		/**
642	<	* invokeAny(null) throws NPE
642	>	* invokeAny(null) throws NullPointerException
643		*/
644	<	public void testInvokeAny1() {
644	>	public void testInvokeAny1() throws Throwable {
645		ExecutorService e = new ForkJoinPool(1);
646		try {
647		e.invokeAny(null);
648	+	shouldThrow();
649		} catch (NullPointerException success) {
770	–	} catch(Exception ex) {
771	–	unexpectedException();
650		} finally {
651		joinPool(e);
652		}
653		}
654
655		/**
656	<	* invokeAny(empty collection) throws IAE
656	>	* invokeAny(empty collection) throws IllegalArgumentException
657		*/
658	<	public void testInvokeAny2() {
658	>	public void testInvokeAny2() throws Throwable {
659		ExecutorService e = new ForkJoinPool(1);
660		try {
661		e.invokeAny(new ArrayList<Callable<String>>());
662	+	shouldThrow();
663		} catch (IllegalArgumentException success) {
785	–	} catch(Exception ex) {
786	–	unexpectedException();
664		} finally {
665		joinPool(e);
666		}
667		}
668
669		/**
670	<	* invokeAny(c) throws NPE if c has null elements
670	>	* invokeAny(c) throws NullPointerException if c has a single null element
671		*/
672	<	public void testInvokeAny3() {
672	>	public void testInvokeAny3() throws Throwable {
673		ExecutorService e = new ForkJoinPool(1);
674	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
675	+	l.add(null);
676	+	try {
677	+	e.invokeAny(l);
678	+	shouldThrow();
679	+	} catch (NullPointerException success) {
680	+	} finally {
681	+	joinPool(e);
682	+	}
683	+	}
684	+
685	+	/**
686	+	* invokeAny(c) throws NullPointerException if c has null elements
687	+	*/
688	+	public void testInvokeAny4() throws Throwable {
689	+	CountDownLatch latch = new CountDownLatch(1);
690	+	ExecutorService e = new ForkJoinPool(1);
691	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
692	+	l.add(latchAwaitingStringTask(latch));
693	+	l.add(null);
694		try {
798	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
799	–	l.add(new StringTask());
800	–	l.add(null);
695		e.invokeAny(l);
696	+	shouldThrow();
697		} catch (NullPointerException success) {
803	–	} catch(Exception ex) {
804	–	ex.printStackTrace();
805	–	unexpectedException();
698		} finally {
699	+	latch.countDown();
700		joinPool(e);
701		}
702		}
#	Line 811 | Line 704 | public class ForkJoinPoolTest extends JS
704		/**
705		* invokeAny(c) throws ExecutionException if no task in c completes
706		*/
707	<	public void testInvokeAny4() {
707	>	public void testInvokeAny5() throws Throwable {
708		ExecutorService e = new ForkJoinPool(1);
709	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
710	+	l.add(new NPETask());
711		try {
817	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
818	–	l.add(new NPETask());
712		e.invokeAny(l);
713	<	} catch(ExecutionException success) {
714	<	} catch (CancellationException success) {
715	<	} catch(Exception ex) {
823	<	unexpectedException();
713	>	shouldThrow();
714	>	} catch (ExecutionException success) {
715	>	assertTrue(success.getCause() instanceof NullPointerException);
716		} finally {
717		joinPool(e);
718		}
#	Line 829 | Line 721 | public class ForkJoinPoolTest extends JS
721		/**
722		* invokeAny(c) returns result of some task in c if at least one completes
723		*/
724	<	public void testInvokeAny5() {
724	>	public void testInvokeAny6() throws Throwable {
725		ExecutorService e = new ForkJoinPool(1);
726		try {
727	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
727	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
728		l.add(new StringTask());
729		l.add(new StringTask());
730		String result = e.invokeAny(l);
731		assertSame(TEST_STRING, result);
840	–	} catch (ExecutionException success) {
841	–	} catch (CancellationException success) {
842	–	} catch(Exception ex) {
843	–	unexpectedException();
732		} finally {
733		joinPool(e);
734		}
735		}
736
737		/**
738	<	* invokeAll(null) throws NPE
738	>	* invokeAll(null) throws NullPointerException
739		*/
740	<	public void testInvokeAll1() {
740	>	public void testInvokeAll1() throws Throwable {
741		ExecutorService e = new ForkJoinPool(1);
742		try {
743		e.invokeAll(null);
744	+	shouldThrow();
745		} catch (NullPointerException success) {
857	–	} catch(Exception ex) {
858	–	unexpectedException();
746		} finally {
747		joinPool(e);
748		}
#	Line 864 | Line 751 | public class ForkJoinPoolTest extends JS
751		/**
752		* invokeAll(empty collection) returns empty collection
753		*/
754	<	public void testInvokeAll2() {
754	>	public void testInvokeAll2() throws InterruptedException {
755		ExecutorService e = new ForkJoinPool(1);
756		try {
757	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
757	>	List<Future<String>> r
758	>	= e.invokeAll(new ArrayList<Callable<String>>());
759		assertTrue(r.isEmpty());
872	–	} catch(Exception ex) {
873	–	unexpectedException();
760		} finally {
761		joinPool(e);
762		}
763		}
764
765		/**
766	<	* invokeAll(c) throws NPE if c has null elements
766	>	* invokeAll(c) throws NullPointerException if c has null elements
767		*/
768	<	public void testInvokeAll3() {
768	>	public void testInvokeAll3() throws InterruptedException {
769		ExecutorService e = new ForkJoinPool(1);
770	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
771	+	l.add(new StringTask());
772	+	l.add(null);
773		try {
885	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
886	–	l.add(new StringTask());
887	–	l.add(null);
774		e.invokeAll(l);
775	+	shouldThrow();
776		} catch (NullPointerException success) {
890	–	} catch(Exception ex) {
891	–	unexpectedException();
777		} finally {
778		joinPool(e);
779		}
780		}
781
782		/**
783	<	* get of returned element of invokeAll(c) throws exception on failed task
783	>	* get of returned element of invokeAll(c) throws
784	>	* ExecutionException on failed task
785		*/
786	<	public void testInvokeAll4() {
786	>	public void testInvokeAll4() throws Throwable {
787		ExecutorService e = new ForkJoinPool(1);
788	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
789	+	l.add(new NPETask());
790	+	List<Future<String>> futures = e.invokeAll(l);
791	+	assertEquals(1, futures.size());
792		try {
793	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
794	<	l.add(new NPETask());
795	<	List<Future<String>> result = e.invokeAll(l);
796	<	assertEquals(1, result.size());
907	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
908	<	it.next().get();
909	<	} catch(ExecutionException success) {
910	<	} catch (CancellationException success) {
911	<	} catch(Exception ex) {
912	<	ex.printStackTrace();
913	<	unexpectedException();
793	>	futures.get(0).get();
794	>	shouldThrow();
795	>	} catch (ExecutionException success) {
796	>	assertTrue(success.getCause() instanceof NullPointerException);
797		} finally {
798		joinPool(e);
799		}
#	Line 919 | Line 802 | public class ForkJoinPoolTest extends JS
802		/**
803		* invokeAll(c) returns results of all completed tasks in c
804		*/
805	<	public void testInvokeAll5() {
805	>	public void testInvokeAll5() throws Throwable {
806		ExecutorService e = new ForkJoinPool(1);
807		try {
808	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
808	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
809		l.add(new StringTask());
810		l.add(new StringTask());
811	<	List<Future<String>> result = e.invokeAll(l);
812	<	assertEquals(2, result.size());
813	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
814	<	assertSame(TEST_STRING, it.next().get());
932	<	} catch (ExecutionException success) {
933	<	} catch (CancellationException success) {
934	<	} catch(Exception ex) {
935	<	ex.printStackTrace();
936	<	unexpectedException();
811	>	List<Future<String>> futures = e.invokeAll(l);
812	>	assertEquals(2, futures.size());
813	>	for (Future<String> future : futures)
814	>	assertSame(TEST_STRING, future.get());
815		} finally {
816		joinPool(e);
817		}
#	Line 941 | Line 819 | public class ForkJoinPoolTest extends JS
819
820
821		/**
822	<	* timed invokeAny(null) throws NPE
822	>	* timed invokeAny(null) throws NullPointerException
823		*/
824	<	public void testTimedInvokeAny1() {
824	>	public void testTimedInvokeAny1() throws Throwable {
825		ExecutorService e = new ForkJoinPool(1);
826		try {
827	<	e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
827	>	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
828	>	shouldThrow();
829		} catch (NullPointerException success) {
951	–	} catch(Exception ex) {
952	–	ex.printStackTrace();
953	–	unexpectedException();
830		} finally {
831		joinPool(e);
832		}
833		}
834
835		/**
836	<	* timed invokeAny(null time unit) throws NPE
836	>	* timed invokeAny(null time unit) throws NullPointerException
837		*/
838	<	public void testTimedInvokeAnyNullTimeUnit() {
838	>	public void testTimedInvokeAnyNullTimeUnit() throws Throwable {
839		ExecutorService e = new ForkJoinPool(1);
840	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
841	+	l.add(new StringTask());
842		try {
965	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
966	–	l.add(new StringTask());
843		e.invokeAny(l, MEDIUM_DELAY_MS, null);
844	+	shouldThrow();
845		} catch (NullPointerException success) {
969	–	} catch(Exception ex) {
970	–	ex.printStackTrace();
971	–	unexpectedException();
846		} finally {
847		joinPool(e);
848		}
849		}
850
851		/**
852	<	* timed invokeAny(empty collection) throws IAE
852	>	* timed invokeAny(empty collection) throws IllegalArgumentException
853		*/
854	<	public void testTimedInvokeAny2() {
854	>	public void testTimedInvokeAny2() throws Throwable {
855		ExecutorService e = new ForkJoinPool(1);
856		try {
857	<	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
857	>	e.invokeAny(new ArrayList<Callable<String>>(),
858	>	MEDIUM_DELAY_MS, MILLISECONDS);
859	>	shouldThrow();
860		} catch (IllegalArgumentException success) {
985	–	} catch(Exception ex) {
986	–	ex.printStackTrace();
987	–	unexpectedException();
861		} finally {
862		joinPool(e);
863		}
864		}
865
866		/**
867	<	* timed invokeAny(c) throws NPE if c has null elements
867	>	* timed invokeAny(c) throws NullPointerException if c has null elements
868		*/
869	<	public void testTimedInvokeAny3() {
869	>	public void testTimedInvokeAny3() throws Throwable {
870	>	CountDownLatch latch = new CountDownLatch(1);
871		ExecutorService e = new ForkJoinPool(1);
872	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
873	+	l.add(latchAwaitingStringTask(latch));
874	+	l.add(null);
875		try {
876	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
877	<	l.add(new StringTask());
1001	<	l.add(null);
1002	<	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
876	>	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
877	>	shouldThrow();
878		} catch (NullPointerException success) {
1004	–	} catch(Exception ex) {
1005	–	ex.printStackTrace();
1006	–	unexpectedException();
879		} finally {
880	+	latch.countDown();
881		joinPool(e);
882		}
883		}
#	Line 1012 | Line 885 | public class ForkJoinPoolTest extends JS
885		/**
886		* timed invokeAny(c) throws ExecutionException if no task completes
887		*/
888	<	public void testTimedInvokeAny4() {
888	>	public void testTimedInvokeAny4() throws Throwable {
889		ExecutorService e = new ForkJoinPool(1);
890	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
891	+	l.add(new NPETask());
892		try {
893	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
894	<	l.add(new NPETask());
895	<	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
896	<	} catch(ExecutionException success) {
1022	<	} catch (CancellationException success) {
1023	<	} catch(Exception ex) {
1024	<	ex.printStackTrace();
1025	<	unexpectedException();
893	>	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
894	>	shouldThrow();
895	>	} catch (ExecutionException success) {
896	>	assertTrue(success.getCause() instanceof NullPointerException);
897		} finally {
898		joinPool(e);
899		}
#	Line 1031 | Line 902 | public class ForkJoinPoolTest extends JS
902		/**
903		* timed invokeAny(c) returns result of some task in c
904		*/
905	<	public void testTimedInvokeAny5() {
905	>	public void testTimedInvokeAny5() throws Throwable {
906		ExecutorService e = new ForkJoinPool(1);
907		try {
908	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
908	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
909		l.add(new StringTask());
910		l.add(new StringTask());
911	<	String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
911	>	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
912		assertSame(TEST_STRING, result);
1042	–	} catch (ExecutionException success) {
1043	–	} catch (CancellationException success) {
1044	–	} catch(Exception ex) {
1045	–	ex.printStackTrace();
1046	–	unexpectedException();
913		} finally {
914		joinPool(e);
915		}
916		}
917
918		/**
919	<	* timed invokeAll(null) throws NPE
919	>	* timed invokeAll(null) throws NullPointerException
920		*/
921	<	public void testTimedInvokeAll1() {
921	>	public void testTimedInvokeAll1() throws Throwable {
922		ExecutorService e = new ForkJoinPool(1);
923		try {
924	<	e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
924	>	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
925	>	shouldThrow();
926		} catch (NullPointerException success) {
1060	–	} catch(Exception ex) {
1061	–	ex.printStackTrace();
1062	–	unexpectedException();
927		} finally {
928		joinPool(e);
929		}
930		}
931
932		/**
933	<	* timed invokeAll(null time unit) throws NPE
933	>	* timed invokeAll(null time unit) throws NullPointerException
934		*/
935	<	public void testTimedInvokeAllNullTimeUnit() {
935	>	public void testTimedInvokeAllNullTimeUnit() throws Throwable {
936		ExecutorService e = new ForkJoinPool(1);
937	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
938	+	l.add(new StringTask());
939		try {
1074	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1075	–	l.add(new StringTask());
940		e.invokeAll(l, MEDIUM_DELAY_MS, null);
941	+	shouldThrow();
942		} catch (NullPointerException success) {
1078	–	} catch(Exception ex) {
1079	–	ex.printStackTrace();
1080	–	unexpectedException();
943		} finally {
944		joinPool(e);
945		}
#	Line 1086 | Line 948 | public class ForkJoinPoolTest extends JS
948		/**
949		* timed invokeAll(empty collection) returns empty collection
950		*/
951	<	public void testTimedInvokeAll2() {
951	>	public void testTimedInvokeAll2() throws InterruptedException {
952		ExecutorService e = new ForkJoinPool(1);
953		try {
954	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
954	>	List<Future<String>> r
955	>	= e.invokeAll(new ArrayList<Callable<String>>(),
956	>	MEDIUM_DELAY_MS, MILLISECONDS);
957		assertTrue(r.isEmpty());
1094	–	} catch(Exception ex) {
1095	–	ex.printStackTrace();
1096	–	unexpectedException();
958		} finally {
959		joinPool(e);
960		}
961		}
962
963		/**
964	<	* timed invokeAll(c) throws NPE if c has null elements
964	>	* timed invokeAll(c) throws NullPointerException if c has null elements
965		*/
966	<	public void testTimedInvokeAll3() {
966	>	public void testTimedInvokeAll3() throws InterruptedException {
967		ExecutorService e = new ForkJoinPool(1);
968	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
969	+	l.add(new StringTask());
970	+	l.add(null);
971		try {
972	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
973	<	l.add(new StringTask());
1110	<	l.add(null);
1111	<	e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
972	>	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
973	>	shouldThrow();
974		} catch (NullPointerException success) {
1113	–	} catch(Exception ex) {
1114	–	ex.printStackTrace();
1115	–	unexpectedException();
975		} finally {
976		joinPool(e);
977		}
#	Line 1121 | Line 980 | public class ForkJoinPoolTest extends JS
980		/**
981		* get of returned element of invokeAll(c) throws exception on failed task
982		*/
983	<	public void testTimedInvokeAll4() {
983	>	public void testTimedInvokeAll4() throws Throwable {
984		ExecutorService e = new ForkJoinPool(1);
985	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
986	+	l.add(new NPETask());
987	+	List<Future<String>> futures
988	+	= e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
989	+	assertEquals(1, futures.size());
990		try {
991	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
992	<	l.add(new NPETask());
993	<	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
994	<	assertEquals(1, result.size());
1131	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1132	<	it.next().get();
1133	<	} catch(ExecutionException success) {
1134	<	} catch (CancellationException success) {
1135	<	} catch(Exception ex) {
1136	<	ex.printStackTrace();
1137	<	unexpectedException();
991	>	futures.get(0).get();
992	>	shouldThrow();
993	>	} catch (ExecutionException success) {
994	>	assertTrue(success.getCause() instanceof NullPointerException);
995		} finally {
996		joinPool(e);
997		}
#	Line 1143 | Line 1000 | public class ForkJoinPoolTest extends JS
1000		/**
1001		* timed invokeAll(c) returns results of all completed tasks in c
1002		*/
1003	<	public void testTimedInvokeAll5() {
1003	>	public void testTimedInvokeAll5() throws Throwable {
1004		ExecutorService e = new ForkJoinPool(1);
1005		try {
1006	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1006	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1007		l.add(new StringTask());
1008		l.add(new StringTask());
1009	<	List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1010	<	assertEquals(2, result.size());
1011	<	for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1012	<	assertSame(TEST_STRING, it.next().get());
1013	<	} catch (ExecutionException success) {
1157	<	} catch (CancellationException success) {
1158	<	} catch(Exception ex) {
1159	<	ex.printStackTrace();
1160	<	unexpectedException();
1009	>	List<Future<String>> futures
1010	>	= e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1011	>	assertEquals(2, futures.size());
1012	>	for (Future<String> future : futures)
1013	>	assertSame(TEST_STRING, future.get());
1014		} finally {
1015		joinPool(e);
1016		}

Diff Legend

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