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.6 by jsr166, Mon Aug 3 22:08:07 2009 UTC vs.
Revision 1.25 by jsr166, Mon Sep 13 20:48:58 2010 UTC

#	Line 4 | Line 4
4		* http://creativecommons.org/licenses/publicdomain
5		*/
6
7	–
7		import junit.framework.*;
8	<	import java.util.*;
9	<	import java.util.concurrent.*;
10	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
11	<	import java.util.concurrent.locks.*;
12	<	import java.security.*;
8	>	import java.util.ArrayList;
9	>	import java.util.Collection;
10	>	import java.util.List;
11	>	import java.util.concurrent.Executors;
12	>	import java.util.concurrent.ExecutorService;
13	>	import java.util.concurrent.AbstractExecutorService;
14	>	import java.util.concurrent.CountDownLatch;
15	>	import java.util.concurrent.Callable;
16	>	import java.util.concurrent.Future;
17	>	import java.util.concurrent.ExecutionException;
18	>	import java.util.concurrent.CancellationException;
19	>	import java.util.concurrent.RejectedExecutionException;
20	>	import java.util.concurrent.ForkJoinPool;
21	>	import java.util.concurrent.ForkJoinTask;
22	>	import java.util.concurrent.ForkJoinWorkerThread;
23	>	import java.util.concurrent.RecursiveTask;
24	>	import java.util.concurrent.TimeUnit;
25	>	import java.util.concurrent.locks.ReentrantLock;
26	>	import java.security.AccessControlException;
27	>	import java.security.Policy;
28	>	import java.security.PrivilegedAction;
29	>	import java.security.PrivilegedExceptionAction;
30
31		public class ForkJoinPoolTest extends JSR166TestCase {
32		public static void main(String[] args) {
33	<	junit.textui.TestRunner.run (suite());
33	>	junit.textui.TestRunner.run(suite());
34		}
35	+
36		public static Test suite() {
37		return new TestSuite(ForkJoinPoolTest.class);
38		}
#	Line 39 | Line 56 | public class ForkJoinPoolTest extends JS
56		// Some classes to test extension and factory methods
57
58		static class MyHandler implements Thread.UncaughtExceptionHandler {
59	<	int catches = 0;
59	>	volatile int catches = 0;
60		public void uncaughtException(Thread t, Throwable e) {
61		++catches;
62		}
#	Line 48 | Line 65 | public class ForkJoinPoolTest extends JS
65		// to test handlers
66		static class FailingFJWSubclass extends ForkJoinWorkerThread {
67		public FailingFJWSubclass(ForkJoinPool p) { super(p) ; }
68	<	protected void onStart() { throw new Error(); }
68	>	protected void onStart() { super.onStart(); throw new Error(); }
69		}
70
71		static class FailingThreadFactory
72		implements ForkJoinPool.ForkJoinWorkerThreadFactory {
73	<	int calls = 0;
73	>	volatile int calls = 0;
74		public ForkJoinWorkerThread newThread(ForkJoinPool p) {
75		if (++calls > 1) return null;
76		return new FailingFJWSubclass(p);
#	Line 142 | Line 159 | public class ForkJoinPoolTest extends JS
159		* tasks, and quiescent running state.
160		*/
161		public void testDefaultInitialState() {
162	<	ForkJoinPool p = null;
162	>	ForkJoinPool p = new ForkJoinPool(1);
163		try {
147	–	p = new ForkJoinPool(1);
164		assertTrue(p.getFactory() ==
165		ForkJoinPool.defaultForkJoinWorkerThreadFactory);
166		assertTrue(p.isQuiescent());
151	–	assertTrue(p.getMaintainsParallelism());
167		assertFalse(p.getAsyncMode());
168		assertTrue(p.getActiveThreadCount() == 0);
169		assertTrue(p.getStealCount() == 0);
#	Line 170 | Line 185 | public class ForkJoinPoolTest extends JS
185		try {
186		new ForkJoinPool(-1);
187		shouldThrow();
188	<	}
174	<	catch (IllegalArgumentException success) {}
188	>	} catch (IllegalArgumentException success) {}
189		}
190
191		/**
#	Line 179 | Line 193 | public class ForkJoinPoolTest extends JS
193		*/
194		public void testConstructor2() {
195		try {
196	<	new ForkJoinPool(1, null);
196	>	new ForkJoinPool(1, null, null, false);
197		shouldThrow();
198	<	} catch (NullPointerException success) {
185	<	}
198	>	} catch (NullPointerException success) {}
199		}
200
201
#	Line 190 | Line 203 | public class ForkJoinPoolTest extends JS
203		* getParallelism returns size set in constructor
204		*/
205		public void testGetParallelism() {
206	<	ForkJoinPool p = null;
194	<	try {
195	<	p = new ForkJoinPool(1);
196	<	assertTrue(p.getParallelism() == 1);
197	<	} finally {
198	<	joinPool(p);
199	<	}
200	<	}
201	<
202	<	/**
203	<	* setParallelism changes reported parallelism level.
204	<	*/
205	<	public void testSetParallelism() {
206	<	ForkJoinPool p = null;
207	<	try {
208	<	p = new ForkJoinPool(1);
209	<	assertTrue(p.getParallelism() == 1);
210	<	p.setParallelism(2);
211	<	assertTrue(p.getParallelism() == 2);
212	<	} finally {
213	<	joinPool(p);
214	<	}
215	<	}
216	<
217	<	/**
218	<	* setParallelism with argument <= 0 throws exception
219	<	*/
220	<	public void testSetParallelism2() {
221	<	ForkJoinPool p = null;
206	>	ForkJoinPool p = new ForkJoinPool(1);
207		try {
223	–	p = new ForkJoinPool(1);
208		assertTrue(p.getParallelism() == 1);
225	–	p.setParallelism(-2);
226	–	shouldThrow();
227	–	} catch (IllegalArgumentException success) {
209		} finally {
210		joinPool(p);
211		}
#	Line 234 | Line 215 | public class ForkJoinPoolTest extends JS
215		* getPoolSize returns number of started workers.
216		*/
217		public void testGetPoolSize() {
218	<	ForkJoinPool p = null;
218	>	ForkJoinPool p = new ForkJoinPool(1);
219		try {
220	<	p = new ForkJoinPool(1);
240	<	assertTrue(p.getPoolSize() == 0);
220	>	assertTrue(p.getActiveThreadCount() == 0);
221		Future<String> future = p.submit(new StringTask());
222		assertTrue(p.getPoolSize() == 1);
243	–
244	–	} finally {
245	–	joinPool(p);
246	–	}
247	–	}
248	–
249	–	/**
250	–	* setMaximumPoolSize changes size reported by getMaximumPoolSize.
251	–	*/
252	–	public void testSetMaximumPoolSize() {
253	–	ForkJoinPool p = null;
254	–	try {
255	–	p = new ForkJoinPool(1);
256	–	p.setMaximumPoolSize(2);
257	–	assertTrue(p.getMaximumPoolSize() == 2);
258	–	} finally {
259	–	joinPool(p);
260	–	}
261	–	}
262	–
263	–	/**
264	–	* setMaximumPoolSize with argument <= 0 throws exception
265	–	*/
266	–	public void testSetMaximumPoolSize2() {
267	–	ForkJoinPool p = null;
268	–	try {
269	–	p = new ForkJoinPool(1);
270	–	p.setMaximumPoolSize(-2);
271	–	shouldThrow();
272	–	} catch (IllegalArgumentException success) {
273	–	} finally {
274	–	joinPool(p);
275	–	}
276	–	}
277	–
278	–	/**
279	–	* setMaintainsParallelism changes policy reported by
280	–	* getMaintainsParallelism.
281	–	*/
282	–	public void testSetMaintainsParallelism() {
283	–	ForkJoinPool p = null;
284	–	try {
285	–	p = new ForkJoinPool(1);
286	–	p.setMaintainsParallelism(false);
287	–	assertFalse(p.getMaintainsParallelism());
288	–	} finally {
289	–	joinPool(p);
290	–	}
291	–	}
292	–
293	–	/**
294	–	* setAsyncMode changes policy reported by
295	–	* getAsyncMode.
296	–	*/
297	–	public void testSetAsyncMode() {
298	–	ForkJoinPool p = null;
299	–	try {
300	–	p = new ForkJoinPool(1);
301	–	p.setAsyncMode(true);
302	–	assertTrue(p.getAsyncMode());
223		} finally {
224		joinPool(p);
225		}
#	Line 312 | Line 232 | public class ForkJoinPoolTest extends JS
232		* performs its defined action
233		*/
234		public void testSetUncaughtExceptionHandler() throws InterruptedException {
235	<	ForkJoinPool p = null;
235	>	MyHandler eh = new MyHandler();
236	>	ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(), eh, false);
237		try {
238	<	p = new ForkJoinPool(1, new FailingThreadFactory());
318	<	MyHandler eh = new MyHandler();
319	<	p.setUncaughtExceptionHandler(eh);
320	<	assertEquals(eh, p.getUncaughtExceptionHandler());
238	>	assert(eh == p.getUncaughtExceptionHandler());
239		p.execute(new FailingTask());
240		Thread.sleep(MEDIUM_DELAY_MS);
241		assertTrue(eh.catches > 0);
242		} finally {
243	+	p.shutdownNow();
244		joinPool(p);
245		}
246		}
247
248		/**
330	–	* setUncaughtExceptionHandler of null removes handler
331	–	*/
332	–	public void testSetUncaughtExceptionHandler2() {
333	–	ForkJoinPool p = null;
334	–	try {
335	–	p = new ForkJoinPool(1);
336	–	p.setUncaughtExceptionHandler(null);
337	–	assertNull(p.getUncaughtExceptionHandler());
338	–	} finally {
339	–	joinPool(p);
340	–	}
341	–	}
342	–
343	–
344	–	/**
249		* After invoking a single task, isQuiescent is true,
250		* queues are empty, threads are not active, and
251		* construction parameters continue to hold
252		*/
253		public void testisQuiescent() throws InterruptedException {
254	<	ForkJoinPool p = null;
254	>	ForkJoinPool p = new ForkJoinPool(2);
255		try {
352	–	p = new ForkJoinPool(2);
256		p.invoke(new FibTask(20));
257		assertTrue(p.getFactory() ==
258		ForkJoinPool.defaultForkJoinWorkerThreadFactory);
259		Thread.sleep(MEDIUM_DELAY_MS);
260		assertTrue(p.isQuiescent());
358	–	assertTrue(p.getMaintainsParallelism());
261		assertFalse(p.getAsyncMode());
262		assertTrue(p.getActiveThreadCount() == 0);
263		assertTrue(p.getQueuedTaskCount() == 0);
#	Line 373 | Line 275 | public class ForkJoinPoolTest extends JS
275		* Completed submit(ForkJoinTask) returns result
276		*/
277		public void testSubmitForkJoinTask() throws Throwable {
278	<	ForkJoinPool p = null;
278	>	ForkJoinPool p = new ForkJoinPool(1);
279		try {
378	–	p = new ForkJoinPool(1);
280		ForkJoinTask<Integer> f = p.submit(new FibTask(8));
281		int r = f.get();
282		assertTrue(r == 21);
#	Line 388 | Line 289 | public class ForkJoinPoolTest extends JS
289		* A task submitted after shutdown is rejected
290		*/
291		public void testSubmitAfterShutdown() {
292	<	ForkJoinPool p = null;
292	>	ForkJoinPool p = new ForkJoinPool(1);
293		try {
393	–	p = new ForkJoinPool(1);
294		p.shutdown();
295		assertTrue(p.isShutdown());
296		ForkJoinTask<Integer> f = p.submit(new FibTask(8));
#	Line 405 | Line 305 | public class ForkJoinPoolTest extends JS
305		* Pool maintains parallelism when using ManagedBlocker
306		*/
307		public void testBlockingForkJoinTask() throws Throwable {
308	<	ForkJoinPool p = null;
308	>	ForkJoinPool p = new ForkJoinPool(4);
309		try {
410	–	p = new ForkJoinPool(4);
310		ReentrantLock lock = new ReentrantLock();
311		ManagedLocker locker = new ManagedLocker(lock);
312		ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
313		p.execute(f);
415	–	assertTrue(p.getPoolSize() >= 4);
314		int r = f.get();
315	<	assertTrue(r ==  832040);
315	>	assertTrue(r == 832040);
316		} finally {
317	<	joinPool(p);
317	>	p.shutdownNow(); // don't wait out shutdown
318		}
319		}
320
#	Line 424 | Line 322 | public class ForkJoinPoolTest extends JS
322		* pollSubmission returns unexecuted submitted task, if present
323		*/
324		public void testPollSubmission() {
325	<	SubFJP p = null;
325	>	SubFJP p = new SubFJP();
326		try {
429	–	p = new SubFJP();
327		ForkJoinTask a = p.submit(new MediumRunnable());
328		ForkJoinTask b = p.submit(new MediumRunnable());
329		ForkJoinTask c = p.submit(new MediumRunnable());
#	Line 442 | Line 339 | public class ForkJoinPoolTest extends JS
339		* drainTasksTo transfers unexecuted submitted tasks, if present
340		*/
341		public void testDrainTasksTo() {
342	<	SubFJP p = null;
342	>	SubFJP p = new SubFJP();
343		try {
447	–	p = new SubFJP();
344		ForkJoinTask a = p.submit(new MediumRunnable());
345		ForkJoinTask b = p.submit(new MediumRunnable());
346		ForkJoinTask c = p.submit(new MediumRunnable());
#	Line 468 | Line 364 | public class ForkJoinPoolTest extends JS
364		*/
365		public void testExecuteRunnable() throws Throwable {
366		ExecutorService e = new ForkJoinPool(1);
367	<	TrackedShortRunnable task = new TrackedShortRunnable();
368	<	assertFalse(task.done);
369	<	Future<?> future = e.submit(task);
370	<	future.get();
371	<	assertTrue(task.done);
367	>	try {
368	>	TrackedShortRunnable task = new TrackedShortRunnable();
369	>	assertFalse(task.done);
370	>	Future<?> future = e.submit(task);
371	>	future.get();
372	>	assertTrue(task.done);
373	>	} finally {
374	>	joinPool(e);
375	>	}
376		}
377
378
#	Line 481 | Line 381 | public class ForkJoinPoolTest extends JS
381		*/
382		public void testSubmitCallable() throws Throwable {
383		ExecutorService e = new ForkJoinPool(1);
384	<	Future<String> future = e.submit(new StringTask());
385	<	String result = future.get();
386	<	assertSame(TEST_STRING, result);
384	>	try {
385	>	Future<String> future = e.submit(new StringTask());
386	>	String result = future.get();
387	>	assertSame(TEST_STRING, result);
388	>	} finally {
389	>	joinPool(e);
390	>	}
391		}
392
393		/**
#	Line 491 | Line 395 | public class ForkJoinPoolTest extends JS
395		*/
396		public void testSubmitRunnable() throws Throwable {
397		ExecutorService e = new ForkJoinPool(1);
398	<	Future<?> future = e.submit(new NoOpRunnable());
399	<	future.get();
400	<	assertTrue(future.isDone());
398	>	try {
399	>	Future<?> future = e.submit(new NoOpRunnable());
400	>	future.get();
401	>	assertTrue(future.isDone());
402	>	} finally {
403	>	joinPool(e);
404	>	}
405		}
406
407		/**
#	Line 501 | Line 409 | public class ForkJoinPoolTest extends JS
409		*/
410		public void testSubmitRunnable2() throws Throwable {
411		ExecutorService e = new ForkJoinPool(1);
412	<	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
413	<	String result = future.get();
414	<	assertSame(TEST_STRING, result);
412	>	try {
413	>	Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
414	>	String result = future.get();
415	>	assertSame(TEST_STRING, result);
416	>	} finally {
417	>	joinPool(e);
418	>	}
419		}
420
421
#	Line 521 | Line 433 | public class ForkJoinPoolTest extends JS
433		} catch (AccessControlException ok) {
434		return;
435		}
436	+
437		try {
438		ExecutorService e = new ForkJoinPool(1);
439	<	Future future = e.submit(Executors.callable(new PrivilegedAction() {
439	>	try {
440	>	Future future = e.submit(Executors.callable(new PrivilegedAction() {
441		public Object run() {
442		return TEST_STRING;
443		}}));
444
445	<	Object result = future.get();
446	<	assertSame(TEST_STRING, result);
447	<	}
448	<	finally {
445	>	Object result = future.get();
446	>	assertSame(TEST_STRING, result);
447	>	} finally {
448	>	joinPool(e);
449	>	}
450	>	} finally {
451		Policy.setPolicy(savedPolicy);
452		}
453		}
#	Line 553 | Line 469 | public class ForkJoinPoolTest extends JS
469
470		try {
471		ExecutorService e = new ForkJoinPool(1);
472	<	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
472	>	try {
473	>	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
474		public Object run() {
475		return TEST_STRING;
476		}}));
477
478	<	Object result = future.get();
479	<	assertSame(TEST_STRING, result);
480	<	}
481	<	finally {
478	>	Object result = future.get();
479	>	assertSame(TEST_STRING, result);
480	>	} finally {
481	>	joinPool(e);
482	>	}
483	>	} finally {
484		Policy.setPolicy(savedPolicy);
485		}
486		}
#	Line 581 | Line 500 | public class ForkJoinPoolTest extends JS
500		return;
501		}
502
584	–
503		try {
504		ExecutorService e = new ForkJoinPool(1);
505	<	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
505	>	try {
506	>	Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
507		public Object run() throws Exception {
508		throw new IndexOutOfBoundsException();
509		}}));
510
511	<	Object result = future.get();
512	<	shouldThrow();
513	<	} catch (ExecutionException success) {
511	>	Object result = future.get();
512	>	shouldThrow();
513	>	} catch (ExecutionException success) {
514	>	assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
515	>	} finally {
516	>	joinPool(e);
517	>	}
518		} finally {
519		Policy.setPolicy(savedPolicy);
520		}
#	Line 601 | Line 524 | public class ForkJoinPoolTest extends JS
524		* execute(null runnable) throws NullPointerException
525		*/
526		public void testExecuteNullRunnable() {
527	+	ExecutorService e = new ForkJoinPool(1);
528		try {
605	–	ExecutorService e = new ForkJoinPool(1);
529		TrackedShortRunnable task = null;
530		Future<?> future = e.submit(task);
531		shouldThrow();
532		} catch (NullPointerException success) {
533	+	} finally {
534	+	joinPool(e);
535		}
536		}
537
#	Line 615 | Line 540 | public class ForkJoinPoolTest extends JS
540		* submit(null callable) throws NullPointerException
541		*/
542		public void testSubmitNullCallable() {
543	+	ExecutorService e = new ForkJoinPool(1);
544		try {
619	–	ExecutorService e = new ForkJoinPool(1);
545		StringTask t = null;
546		Future<String> future = e.submit(t);
547		shouldThrow();
548		} catch (NullPointerException success) {
549	+	} finally {
550	+	joinPool(e);
551		}
552		}
553
#	Line 633 | Line 560 | public class ForkJoinPoolTest extends JS
560		final ForkJoinPool p = new ForkJoinPool(1);
561
562		Thread t = new Thread(new CheckedInterruptedRunnable() {
563	<	void realRun() throws Throwable {
563	>	public void realRun() throws Throwable {
564		p.submit(new CheckedCallable<Object>() {
565		public Object realCall() throws Throwable {
566	<	Thread.sleep(MEDIUM_DELAY_MS);
566	>	try {
567	>	Thread.sleep(MEDIUM_DELAY_MS);
568	>	} catch (InterruptedException ok) {
569	>	}
570		return null;
571		}}).get();
572		}});
#	Line 644 | Line 574 | public class ForkJoinPoolTest extends JS
574		t.start();
575		Thread.sleep(SHORT_DELAY_MS);
576		t.interrupt();
577	+	t.join();
578	+	p.shutdownNow();
579		joinPool(p);
580		}
581
#	Line 653 | Line 585 | public class ForkJoinPoolTest extends JS
585		*/
586		public void testSubmitEE() throws Throwable {
587		ForkJoinPool p = new ForkJoinPool(1);
656	–
588		try {
589	<	Callable c = new Callable() {
590	<	public Object call() {
591	<	int i = 5/0;
592	<	return Boolean.TRUE;
593	<	}
663	<	};
664	<
665	<	for (int i = 0; i < 5; i++) {
666	<	p.submit(c).get();
667	<	}
589	>	p.submit(new Callable() {
590	>	public Object call() {
591	>	int i = 5/0;
592	>	return Boolean.TRUE;
593	>	}}).get();
594		shouldThrow();
595		} catch (ExecutionException success) {
596	+	assertTrue(success.getCause() instanceof ArithmeticException);
597	+	} finally {
598	+	joinPool(p);
599		}
671	–	joinPool(p);
600		}
601
602		/**
#	Line 700 | Line 628 | public class ForkJoinPoolTest extends JS
628		}
629
630		/**
631	<	* invokeAny(c) throws NullPointerException if c has null elements
631	>	* invokeAny(c) throws NullPointerException if c has a single null element
632		*/
633		public void testInvokeAny3() throws Throwable {
634		ExecutorService e = new ForkJoinPool(1);
635	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
636	+	l.add(null);
637		try {
708	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
709	–	l.add(new StringTask());
710	–	l.add(null);
638		e.invokeAny(l);
639		shouldThrow();
640		} catch (NullPointerException success) {
#	Line 717 | Line 644 | public class ForkJoinPoolTest extends JS
644		}
645
646		/**
647	<	* invokeAny(c) throws ExecutionException if no task in c completes
647	>	* invokeAny(c) throws NullPointerException if c has null elements
648		*/
649		public void testInvokeAny4() throws Throwable {
650	+	CountDownLatch latch = new CountDownLatch(1);
651	+	ExecutorService e = new ForkJoinPool(1);
652	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
653	+	l.add(latchAwaitingStringTask(latch));
654	+	l.add(null);
655	+	try {
656	+	e.invokeAny(l);
657	+	shouldThrow();
658	+	} catch (NullPointerException success) {
659	+	} finally {
660	+	latch.countDown();
661	+	joinPool(e);
662	+	}
663	+	}
664	+
665	+	/**
666	+	* invokeAny(c) throws ExecutionException if no task in c completes
667	+	*/
668	+	public void testInvokeAny5() throws Throwable {
669		ExecutorService e = new ForkJoinPool(1);
670	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
671	+	l.add(new NPETask());
672		try {
725	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
726	–	l.add(new NPETask());
673		e.invokeAny(l);
674		shouldThrow();
675		} catch (ExecutionException success) {
676	+	assertTrue(success.getCause() instanceof NullPointerException);
677		} finally {
678		joinPool(e);
679		}
#	Line 735 | Line 682 | public class ForkJoinPoolTest extends JS
682		/**
683		* invokeAny(c) returns result of some task in c if at least one completes
684		*/
685	<	public void testInvokeAny5() throws Throwable {
685	>	public void testInvokeAny6() throws Throwable {
686		ExecutorService e = new ForkJoinPool(1);
687		try {
688	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
688	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
689		l.add(new StringTask());
690		l.add(new StringTask());
691		String result = e.invokeAny(l);
#	Line 781 | Line 728 | public class ForkJoinPoolTest extends JS
728		*/
729		public void testInvokeAll3() throws InterruptedException {
730		ExecutorService e = new ForkJoinPool(1);
731	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
732	+	l.add(new StringTask());
733	+	l.add(null);
734		try {
785	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
786	–	l.add(new StringTask());
787	–	l.add(null);
735		e.invokeAll(l);
736		shouldThrow();
737		} catch (NullPointerException success) {
#	Line 799 | Line 746 | public class ForkJoinPoolTest extends JS
746		*/
747		public void testInvokeAll4() throws Throwable {
748		ExecutorService e = new ForkJoinPool(1);
749	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
750	+	l.add(new NPETask());
751	+	List<Future<String>> futures = e.invokeAll(l);
752	+	assertEquals(1, futures.size());
753		try {
754	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
804	<	l.add(new NPETask());
805	<	List<Future<String>> result = e.invokeAll(l);
806	<	assertEquals(1, result.size());
807	<	for (Future<String> future : result)
808	<	future.get();
754	>	futures.get(0).get();
755		shouldThrow();
756		} catch (ExecutionException success) {
757	+	assertTrue(success.getCause() instanceof NullPointerException);
758		} finally {
759		joinPool(e);
760		}
#	Line 819 | Line 766 | public class ForkJoinPoolTest extends JS
766		public void testInvokeAll5() throws Throwable {
767		ExecutorService e = new ForkJoinPool(1);
768		try {
769	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
769	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
770		l.add(new StringTask());
771		l.add(new StringTask());
772	<	List<Future<String>> result = e.invokeAll(l);
773	<	assertEquals(2, result.size());
774	<	for (Future<String> future : result)
772	>	List<Future<String>> futures = e.invokeAll(l);
773	>	assertEquals(2, futures.size());
774	>	for (Future<String> future : futures)
775		assertSame(TEST_STRING, future.get());
776		} finally {
777		joinPool(e);
#	Line 838 | Line 785 | public class ForkJoinPoolTest extends JS
785		public void testTimedInvokeAny1() throws Throwable {
786		ExecutorService e = new ForkJoinPool(1);
787		try {
788	<	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
788	>	e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
789		shouldThrow();
790		} catch (NullPointerException success) {
791		} finally {
#	Line 851 | Line 798 | public class ForkJoinPoolTest extends JS
798		*/
799		public void testTimedInvokeAnyNullTimeUnit() throws Throwable {
800		ExecutorService e = new ForkJoinPool(1);
801	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
802	+	l.add(new StringTask());
803		try {
855	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
856	–	l.add(new StringTask());
804		e.invokeAny(l, MEDIUM_DELAY_MS, null);
805		shouldThrow();
806		} catch (NullPointerException success) {
#	Line 869 | Line 816 | public class ForkJoinPoolTest extends JS
816		ExecutorService e = new ForkJoinPool(1);
817		try {
818		e.invokeAny(new ArrayList<Callable<String>>(),
819	<	MEDIUM_DELAY_MS, MILLISECONDS);
819	>	MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
820		shouldThrow();
821		} catch (IllegalArgumentException success) {
822		} finally {
#	Line 881 | Line 828 | public class ForkJoinPoolTest extends JS
828		* timed invokeAny(c) throws NullPointerException if c has null elements
829		*/
830		public void testTimedInvokeAny3() throws Throwable {
831	+	CountDownLatch latch = new CountDownLatch(1);
832		ExecutorService e = new ForkJoinPool(1);
833	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
834	+	l.add(latchAwaitingStringTask(latch));
835	+	l.add(null);
836		try {
837	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
887	<	l.add(new StringTask());
888	<	l.add(null);
889	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
837	>	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
838		shouldThrow();
839		} catch (NullPointerException success) {
840		} finally {
841	+	latch.countDown();
842		joinPool(e);
843		}
844		}
#	Line 899 | Line 848 | public class ForkJoinPoolTest extends JS
848		*/
849		public void testTimedInvokeAny4() throws Throwable {
850		ExecutorService e = new ForkJoinPool(1);
851	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
852	+	l.add(new NPETask());
853		try {
854	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
904	<	l.add(new NPETask());
905	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
854	>	e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
855		shouldThrow();
856		} catch (ExecutionException success) {
857	+	assertTrue(success.getCause() instanceof NullPointerException);
858		} finally {
859		joinPool(e);
860		}
#	Line 916 | Line 866 | public class ForkJoinPoolTest extends JS
866		public void testTimedInvokeAny5() throws Throwable {
867		ExecutorService e = new ForkJoinPool(1);
868		try {
869	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
869	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
870		l.add(new StringTask());
871		l.add(new StringTask());
872	<	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
872	>	String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
873		assertSame(TEST_STRING, result);
874		} finally {
875		joinPool(e);
#	Line 932 | Line 882 | public class ForkJoinPoolTest extends JS
882		public void testTimedInvokeAll1() throws Throwable {
883		ExecutorService e = new ForkJoinPool(1);
884		try {
885	<	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
885	>	e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
886		shouldThrow();
887		} catch (NullPointerException success) {
888		} finally {
#	Line 945 | Line 895 | public class ForkJoinPoolTest extends JS
895		*/
896		public void testTimedInvokeAllNullTimeUnit() throws Throwable {
897		ExecutorService e = new ForkJoinPool(1);
898	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
899	+	l.add(new StringTask());
900		try {
949	–	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
950	–	l.add(new StringTask());
901		e.invokeAll(l, MEDIUM_DELAY_MS, null);
902		shouldThrow();
903		} catch (NullPointerException success) {
#	Line 964 | Line 914 | public class ForkJoinPoolTest extends JS
914		try {
915		List<Future<String>> r
916		= e.invokeAll(new ArrayList<Callable<String>>(),
917	<	MEDIUM_DELAY_MS, MILLISECONDS);
917	>	MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
918		assertTrue(r.isEmpty());
919		} finally {
920		joinPool(e);
#	Line 976 | Line 926 | public class ForkJoinPoolTest extends JS
926		*/
927		public void testTimedInvokeAll3() throws InterruptedException {
928		ExecutorService e = new ForkJoinPool(1);
929	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
930	+	l.add(new StringTask());
931	+	l.add(null);
932		try {
933	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
981	<	l.add(new StringTask());
982	<	l.add(null);
983	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
933	>	e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
934		shouldThrow();
935		} catch (NullPointerException success) {
936		} finally {
#	Line 993 | Line 943 | public class ForkJoinPoolTest extends JS
943		*/
944		public void testTimedInvokeAll4() throws Throwable {
945		ExecutorService e = new ForkJoinPool(1);
946	+	List<Callable<String>> l = new ArrayList<Callable<String>>();
947	+	l.add(new NPETask());
948	+	List<Future<String>> futures
949	+	= e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
950	+	assertEquals(1, futures.size());
951		try {
952	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
998	<	l.add(new NPETask());
999	<	List<Future<String>> result
1000	<	= e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1001	<	assertEquals(1, result.size());
1002	<	for (Future<String> future : result)
1003	<	future.get();
952	>	futures.get(0).get();
953		shouldThrow();
954		} catch (ExecutionException success) {
955	+	assertTrue(success.getCause() instanceof NullPointerException);
956		} finally {
957		joinPool(e);
958		}
#	Line 1014 | Line 964 | public class ForkJoinPoolTest extends JS
964		public void testTimedInvokeAll5() throws Throwable {
965		ExecutorService e = new ForkJoinPool(1);
966		try {
967	<	ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
967	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
968		l.add(new StringTask());
969		l.add(new StringTask());
970	<	List<Future<String>> result
971	<	= e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
972	<	assertEquals(2, result.size());
973	<	for (Future<String> future : result)
970	>	List<Future<String>> futures
971	>	= e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
972	>	assertEquals(2, futures.size());
973	>	for (Future<String> future : futures)
974		assertSame(TEST_STRING, future.get());
975		} finally {
976		joinPool(e);

Diff Legend

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