ViewVC Help

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

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

Comparing jsr166/src/test/tck/CountedCompleterTest.java (file contents):
Revision 1.2 by dl, Thu Mar 21 16:26:43 2013 UTC vs.
Revision 1.33 by jsr166, Mon May 29 19:15:02 2017 UTC

#	Line 3 | Line 3
3		* Expert Group and released to the public domain, as explained at
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6	<	import java.util.concurrent.ExecutionException;
6	>
7	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
8	>
9	>	import java.util.HashSet;
10		import java.util.concurrent.CancellationException;
11	+	import java.util.concurrent.CountedCompleter;
12	+	import java.util.concurrent.ExecutionException;
13		import java.util.concurrent.ForkJoinPool;
14		import java.util.concurrent.ForkJoinTask;
10	–	import java.util.concurrent.CountedCompleter;
11	–	import java.util.concurrent.ForkJoinWorkerThread;
12	–	import java.util.concurrent.RecursiveAction;
13	–	import java.util.concurrent.TimeUnit;
15		import java.util.concurrent.TimeoutException;
16	<	import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
17	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
18	<	import static java.util.concurrent.TimeUnit.SECONDS;
19	<	import java.util.HashSet;
20	<	import junit.framework.*;
16	>	import java.util.concurrent.atomic.AtomicInteger;
17	>	import java.util.concurrent.atomic.AtomicReference;
18	>
19	>	import junit.framework.Test;
20	>	import junit.framework.TestSuite;
21
22		public class CountedCompleterTest extends JSR166TestCase {
23
24		public static void main(String[] args) {
25	<	junit.textui.TestRunner.run(suite());
25	>	main(suite(), args);
26		}
27
28		public static Test suite() {
#	Line 32 | Line 33 | public class CountedCompleterTest extend
33		static final int mainPoolSize =
34		Math.max(2, Runtime.getRuntime().availableProcessors());
35
35	–	/**
36	–	* Analog of CheckedRunnable for ForkJoinTasks
37	–	*/
38	–	public abstract class CheckedFJTask extends RecursiveAction {
39	–	protected abstract void realCompute() throws Throwable;
40	–
41	–	public final void compute() {
42	–	try {
43	–	realCompute();
44	–	} catch (Throwable t) {
45	–	threadUnexpectedException(t);
46	–	}
47	–	}
48	–	}
49	–
36		private static ForkJoinPool mainPool() {
37		return new ForkJoinPool(mainPoolSize);
38		}
#	Line 62 | Line 48 | public class CountedCompleterTest extend
48		}
49
50		private void testInvokeOnPool(ForkJoinPool pool, ForkJoinTask a) {
51	<	try {
51	>	try (PoolCleaner cleaner = cleaner(pool)) {
52		assertFalse(a.isDone());
53		assertFalse(a.isCompletedNormally());
54		assertFalse(a.isCompletedAbnormally());
#	Line 78 | Line 64 | public class CountedCompleterTest extend
64		assertFalse(a.isCancelled());
65		assertNull(a.getException());
66		assertNull(a.getRawResult());
81	–	} finally {
82	–	joinPool(pool);
67		}
68		}
69
#	Line 92 | Line 76 | public class CountedCompleterTest extend
76		assertNull(a.getRawResult());
77
78		try {
79	<	a.get(0L, SECONDS);
79	>	a.get(randomExpiredTimeout(), randomTimeUnit());
80		shouldThrow();
81		} catch (TimeoutException success) {
82		} catch (Throwable fail) { threadUnexpectedException(fail); }
83		}
84
85	<	<T> void checkCompletedNormally(CountedCompleter<T> a) {
102	<	checkCompletedNormally(a, null);
103	<	}
104	<
105	<	<T> void checkCompletedNormally(CountedCompleter<T> a, T expected) {
85	>	void checkCompletedNormally(CountedCompleter<?> a) {
86		assertTrue(a.isDone());
87		assertFalse(a.isCancelled());
88		assertTrue(a.isCompletedNormally());
89		assertFalse(a.isCompletedAbnormally());
90		assertNull(a.getException());
91	<	assertSame(expected, a.getRawResult());
91	>	assertNull(a.getRawResult());
92
93		{
94		Thread.currentThread().interrupt();
95	<	long t0 = System.nanoTime();
96	<	assertSame(expected, a.join());
97	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
95	>	long startTime = System.nanoTime();
96	>	assertNull(a.join());
97	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
98		Thread.interrupted();
99		}
100
101		{
102		Thread.currentThread().interrupt();
103	<	long t0 = System.nanoTime();
103	>	long startTime = System.nanoTime();
104		a.quietlyJoin();        // should be no-op
105	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
105	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
106		Thread.interrupted();
107		}
108
109		assertFalse(a.cancel(false));
110		assertFalse(a.cancel(true));
111		try {
112	<	assertSame(expected, a.get());
113	<	} catch (Throwable fail) { threadUnexpectedException(fail); }
134	<	try {
135	<	assertSame(expected, a.get(5L, SECONDS));
112	>	assertNull(a.get());
113	>	assertNull(a.get(randomTimeout(), randomTimeUnit()));
114		} catch (Throwable fail) { threadUnexpectedException(fail); }
115		}
116
#	Line 155 | Line 133 | public class CountedCompleterTest extend
133		Thread.interrupted();
134
135		{
136	<	long t0 = System.nanoTime();
136	>	long startTime = System.nanoTime();
137		a.quietlyJoin();        // should be no-op
138	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
138	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
139		}
140
141		try {
#	Line 167 | Line 145 | public class CountedCompleterTest extend
145		} catch (Throwable fail) { threadUnexpectedException(fail); }
146
147		try {
148	<	a.get(5L, SECONDS);
148	>	a.get(randomTimeout(), randomTimeUnit());
149		shouldThrow();
150		} catch (CancellationException success) {
151		} catch (Throwable fail) { threadUnexpectedException(fail); }
#	Line 193 | Line 171 | public class CountedCompleterTest extend
171		Thread.interrupted();
172
173		{
174	<	long t0 = System.nanoTime();
174	>	long startTime = System.nanoTime();
175		a.quietlyJoin();        // should be no-op
176	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
176	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
177		}
178
179		try {
#	Line 206 | Line 184 | public class CountedCompleterTest extend
184		} catch (Throwable fail) { threadUnexpectedException(fail); }
185
186		try {
187	<	a.get(5L, SECONDS);
187	>	a.get(randomTimeout(), randomTimeUnit());
188		shouldThrow();
189		} catch (ExecutionException success) {
190		assertSame(t.getClass(), success.getCause().getClass());
191		} catch (Throwable fail) { threadUnexpectedException(fail); }
192	+
193	+	try {
194	+	a.invoke();
195	+	shouldThrow();
196	+	} catch (Throwable success) {
197	+	assertSame(t, success);
198	+	}
199		}
200
201		public static final class FJException extends RuntimeException {
202		FJException() { super(); }
203		}
204
205	<	static final class NoopCountedCompleter extends CountedCompleter {
206	<	boolean post; // set true if onCompletion called
207	<	NoopCountedCompleter() { super(); }
208	<	NoopCountedCompleter(CountedCompleter p) { super(p); }
209	<	public void compute() {}
210	<	public final void onCompletion(CountedCompleter caller) {
211	<	post = true;
205	>	abstract class CheckedCC extends CountedCompleter<Object> {
206	>	final AtomicInteger computeN = new AtomicInteger(0);
207	>	final AtomicInteger onCompletionN = new AtomicInteger(0);
208	>	final AtomicInteger onExceptionalCompletionN = new AtomicInteger(0);
209	>	final AtomicInteger setRawResultN = new AtomicInteger(0);
210	>	final AtomicReference<Object> rawResult = new AtomicReference<>(null);
211	>	int computeN() { return computeN.get(); }
212	>	int onCompletionN() { return onCompletionN.get(); }
213	>	int onExceptionalCompletionN() { return onExceptionalCompletionN.get(); }
214	>	int setRawResultN() { return setRawResultN.get(); }
215	>
216	>	CheckedCC() { super(); }
217	>	CheckedCC(CountedCompleter p) { super(p); }
218	>	CheckedCC(CountedCompleter p, int n) { super(p, n); }
219	>	abstract void realCompute();
220	>	public final void compute() {
221	>	computeN.incrementAndGet();
222	>	realCompute();
223	>	}
224	>	public void onCompletion(CountedCompleter caller) {
225	>	onCompletionN.incrementAndGet();
226	>	super.onCompletion(caller);
227	>	}
228	>	public boolean onExceptionalCompletion(Throwable ex,
229	>	CountedCompleter caller) {
230	>	onExceptionalCompletionN.incrementAndGet();
231	>	assertNotNull(ex);
232	>	assertTrue(isCompletedAbnormally());
233	>	assertTrue(super.onExceptionalCompletion(ex, caller));
234	>	return true;
235	>	}
236	>	protected void setRawResult(Object t) {
237	>	setRawResultN.incrementAndGet();
238	>	rawResult.set(t);
239	>	super.setRawResult(t);
240	>	}
241	>	void checkIncomplete() {
242	>	assertEquals(0, computeN());
243	>	assertEquals(0, onCompletionN());
244	>	assertEquals(0, onExceptionalCompletionN());
245	>	assertEquals(0, setRawResultN());
246	>	checkNotDone(this);
247	>	}
248	>	void checkCompletes(Object rawResult) {
249	>	checkIncomplete();
250	>	int pendingCount = getPendingCount();
251	>	complete(rawResult);
252	>	assertEquals(pendingCount, getPendingCount());
253	>	assertEquals(0, computeN());
254	>	assertEquals(1, onCompletionN());
255	>	assertEquals(0, onExceptionalCompletionN());
256	>	assertEquals(1, setRawResultN());
257	>	assertSame(rawResult, this.rawResult.get());
258	>	checkCompletedNormally(this);
259	>	}
260	>	void checkCompletesExceptionally(Throwable ex) {
261	>	checkIncomplete();
262	>	completeExceptionally(ex);
263	>	checkCompletedExceptionally(ex);
264	>	}
265	>	void checkCompletedExceptionally(Throwable ex) {
266	>	assertEquals(0, computeN());
267	>	assertEquals(0, onCompletionN());
268	>	assertEquals(1, onExceptionalCompletionN());
269	>	assertEquals(0, setRawResultN());
270	>	assertNull(this.rawResult.get());
271	>	checkCompletedAbnormally(this, ex);
272		}
273		}
274
275	+	final class NoopCC extends CheckedCC {
276	+	NoopCC() { super(); }
277	+	NoopCC(CountedCompleter p) { super(p); }
278	+	NoopCC(CountedCompleter p, int initialPendingCount) {
279	+	super(p, initialPendingCount);
280	+	}
281	+	protected void realCompute() {}
282	+	}
283	+
284		/**
285	<	* A newly constructed CountedCompleter is not completed;
286	<	* complete() causes completion.
285	>	* A newly constructed CountedCompleter is not completed;
286	>	* complete() causes completion. pendingCount is ignored.
287		*/
288		public void testComplete() {
289	<	NoopCountedCompleter a = new NoopCountedCompleter();
290	<	assertFalse(a.isDone());
291	<	assertFalse(a.isCompletedNormally());
292	<	assertFalse(a.isCompletedAbnormally());
293	<	assertFalse(a.isCancelled());
294	<	assertNull(a.getException());
295	<	assertNull(a.getRawResult());
296	<	assertFalse(a.post);
297	<	a.complete(null);
298	<	assertTrue(a.post);
299	<	assertTrue(a.isDone());
246	<	assertTrue(a.isCompletedNormally());
247	<	assertFalse(a.isCompletedAbnormally());
248	<	assertFalse(a.isCancelled());
249	<	assertNull(a.getException());
250	<	assertNull(a.getRawResult());
289	>	for (Object x : new Object[] { Boolean.TRUE, null }) {
290	>	for (int pendingCount : new int[] { 0, 42 }) {
291	>	testComplete(new NoopCC(), x, pendingCount);
292	>	testComplete(new NoopCC(new NoopCC()), x, pendingCount);
293	>	}
294	>	}
295	>	}
296	>	void testComplete(NoopCC cc, Object x, int pendingCount) {
297	>	cc.setPendingCount(pendingCount);
298	>	cc.checkCompletes(x);
299	>	assertEquals(pendingCount, cc.getPendingCount());
300		}
301
302		/**
303		* completeExceptionally completes exceptionally
304		*/
305		public void testCompleteExceptionally() {
306	<	NoopCountedCompleter a = new NoopCountedCompleter();
307	<	assertFalse(a.isDone());
308	<	assertFalse(a.isCompletedNormally());
309	<	assertFalse(a.isCompletedAbnormally());
310	<	assertFalse(a.isCancelled());
311	<	assertNull(a.getException());
312	<	assertNull(a.getRawResult());
313	<	assertFalse(a.post);
314	<	a.completeExceptionally(new FJException());
315	<	assertFalse(a.post);
316	<	assertTrue(a.isDone());
317	<	assertFalse(a.isCompletedNormally());
318	<	assertTrue(a.isCompletedAbnormally());
319	<	assertFalse(a.isCancelled());
320	<	assertTrue(a.getException() instanceof FJException);
321	<	assertNull(a.getRawResult());
306	>	new NoopCC()
307	>	.checkCompletesExceptionally(new FJException());
308	>	new NoopCC(new NoopCC())
309	>	.checkCompletesExceptionally(new FJException());
310	>	}
311	>
312	>	/**
313	>	* completeExceptionally(null) surprisingly has the same effect as
314	>	* completeExceptionally(new RuntimeException())
315	>	*/
316	>	public void testCompleteExceptionally_null() {
317	>	NoopCC a = new NoopCC();
318	>	a.completeExceptionally(null);
319	>	try {
320	>	a.invoke();
321	>	shouldThrow();
322	>	} catch (RuntimeException success) {
323	>	assertSame(success.getClass(), RuntimeException.class);
324	>	assertNull(success.getCause());
325	>	a.checkCompletedExceptionally(success);
326	>	}
327		}
328
329		/**
330		* setPendingCount sets the reported pending count
331		*/
332		public void testSetPendingCount() {
333	<	NoopCountedCompleter a = new NoopCountedCompleter();
333	>	NoopCC a = new NoopCC();
334		assertEquals(0, a.getPendingCount());
335	<	a.setPendingCount(1);
336	<	assertEquals(1, a.getPendingCount());
337	<	a.setPendingCount(27);
338	<	assertEquals(27, a.getPendingCount());
335	>	int[] vals = {
336	>	-1, 0, 1,
337	>	Integer.MIN_VALUE,
338	>	Integer.MAX_VALUE,
339	>	};
340	>	for (int val : vals) {
341	>	a.setPendingCount(val);
342	>	assertEquals(val, a.getPendingCount());
343	>	}
344		}
345
346		/**
347		* addToPendingCount adds to the reported pending count
348		*/
349		public void testAddToPendingCount() {
350	<	NoopCountedCompleter a = new NoopCountedCompleter();
350	>	NoopCC a = new NoopCC();
351		assertEquals(0, a.getPendingCount());
352		a.addToPendingCount(1);
353		assertEquals(1, a.getPendingCount());
354		a.addToPendingCount(27);
355		assertEquals(28, a.getPendingCount());
356	+	a.addToPendingCount(-28);
357	+	assertEquals(0, a.getPendingCount());
358		}
359
360		/**
361		* decrementPendingCountUnlessZero decrements reported pending
362		* count unless zero
363		*/
364	<	public void testDecrementPendingCount() {
365	<	NoopCountedCompleter a = new NoopCountedCompleter();
366	<	assertEquals(0, a.getPendingCount());
367	<	a.addToPendingCount(1);
364	>	public void testDecrementPendingCountUnlessZero() {
365	>	NoopCC a = new NoopCC(null, 2);
366	>	assertEquals(2, a.getPendingCount());
367	>	assertEquals(2, a.decrementPendingCountUnlessZero());
368		assertEquals(1, a.getPendingCount());
369	<	a.decrementPendingCountUnlessZero();
369	>	assertEquals(1, a.decrementPendingCountUnlessZero());
370		assertEquals(0, a.getPendingCount());
371	<	a.decrementPendingCountUnlessZero();
371	>	assertEquals(0, a.decrementPendingCountUnlessZero());
372		assertEquals(0, a.getPendingCount());
373	+	a.setPendingCount(-1);
374	+	assertEquals(-1, a.decrementPendingCountUnlessZero());
375	+	assertEquals(-2, a.getPendingCount());
376	+	}
377	+
378	+	/**
379	+	* compareAndSetPendingCount compares and sets the reported
380	+	* pending count
381	+	*/
382	+	public void testCompareAndSetPendingCount() {
383	+	NoopCC a = new NoopCC();
384	+	assertEquals(0, a.getPendingCount());
385	+	assertTrue(a.compareAndSetPendingCount(0, 1));
386	+	assertEquals(1, a.getPendingCount());
387	+	assertTrue(a.compareAndSetPendingCount(1, 2));
388	+	assertEquals(2, a.getPendingCount());
389	+	assertFalse(a.compareAndSetPendingCount(1, 3));
390	+	assertEquals(2, a.getPendingCount());
391		}
392
393		/**
394		* getCompleter returns parent or null if at root
395		*/
396		public void testGetCompleter() {
397	<	NoopCountedCompleter a = new NoopCountedCompleter();
397	>	NoopCC a = new NoopCC();
398		assertNull(a.getCompleter());
399	<	CountedCompleter b = new NoopCountedCompleter(a);
400	<	assertEquals(a, b.getCompleter());
399	>	CountedCompleter b = new NoopCC(a);
400	>	assertSame(a, b.getCompleter());
401	>	CountedCompleter c = new NoopCC(b);
402	>	assertSame(b, c.getCompleter());
403		}
404	<
404	>
405		/**
406		* getRoot returns self if no parent, else parent's root
407		*/
408		public void testGetRoot() {
409	<	NoopCountedCompleter a = new NoopCountedCompleter();
410	<	NoopCountedCompleter b = new NoopCountedCompleter(a);
411	<	assertEquals(a, a.getRoot());
412	<	assertEquals(a, b.getRoot());
409	>	NoopCC a = new NoopCC();
410	>	NoopCC b = new NoopCC(a);
411	>	NoopCC c = new NoopCC(b);
412	>	assertSame(a, a.getRoot());
413	>	assertSame(a, b.getRoot());
414	>	assertSame(a, c.getRoot());
415		}
416	<
416	>
417		/**
418	<	* tryComplete causes completion if pending count is zero
418	>	* tryComplete decrements pending count unless zero, in which case
419	>	* causes completion
420		*/
421	<	public void testTryComplete1() {
422	<	NoopCountedCompleter a = new NoopCountedCompleter();
421	>	public void testTryComplete() {
422	>	NoopCC a = new NoopCC();
423		assertEquals(0, a.getPendingCount());
424	+	int n = 3;
425	+	a.setPendingCount(n);
426	+	for (; n > 0; n--) {
427	+	assertEquals(n, a.getPendingCount());
428	+	a.tryComplete();
429	+	a.checkIncomplete();
430	+	assertEquals(n - 1, a.getPendingCount());
431	+	}
432		a.tryComplete();
433	<	assertTrue(a.post);
434	<	assertTrue(a.isDone());
433	>	assertEquals(0, a.computeN());
434	>	assertEquals(1, a.onCompletionN());
435	>	assertEquals(0, a.onExceptionalCompletionN());
436	>	assertEquals(0, a.setRawResultN());
437	>	checkCompletedNormally(a);
438		}
439
440		/**
441	<	* propagateCompletion causes completion without invokein
442	<	* onCompletion if pending count is zero
441	>	* propagateCompletion decrements pending count unless zero, in
442	>	* which case causes completion, without invoking onCompletion
443		*/
444		public void testPropagateCompletion() {
445	<	NoopCountedCompleter a = new NoopCountedCompleter();
445	>	NoopCC a = new NoopCC();
446		assertEquals(0, a.getPendingCount());
447	+	int n = 3;
448	+	a.setPendingCount(n);
449	+	for (; n > 0; n--) {
450	+	assertEquals(n, a.getPendingCount());
451	+	a.propagateCompletion();
452	+	a.checkIncomplete();
453	+	assertEquals(n - 1, a.getPendingCount());
454	+	}
455		a.propagateCompletion();
456	<	assertFalse(a.post);
457	<	assertTrue(a.isDone());
458	<	}
459	<
460	<	/**
358	<	* tryComplete decrments pending count unless zero
359	<	*/
360	<	public void testTryComplete2() {
361	<	NoopCountedCompleter a = new NoopCountedCompleter();
362	<	assertEquals(0, a.getPendingCount());
363	<	a.setPendingCount(1);
364	<	a.tryComplete();
365	<	assertFalse(a.post);
366	<	assertFalse(a.isDone());
367	<	assertEquals(0, a.getPendingCount());
368	<	a.tryComplete();
369	<	assertTrue(a.post);
370	<	assertTrue(a.isDone());
456	>	assertEquals(0, a.computeN());
457	>	assertEquals(0, a.onCompletionN());
458	>	assertEquals(0, a.onExceptionalCompletionN());
459	>	assertEquals(0, a.setRawResultN());
460	>	checkCompletedNormally(a);
461		}
462
463		/**
464		* firstComplete returns this if pending count is zero else null
465		*/
466		public void testFirstComplete() {
467	<	NoopCountedCompleter a = new NoopCountedCompleter();
467	>	NoopCC a = new NoopCC();
468		a.setPendingCount(1);
469		assertNull(a.firstComplete());
470	<	assertEquals(a, a.firstComplete());
470	>	a.checkIncomplete();
471	>	assertSame(a, a.firstComplete());
472	>	a.checkIncomplete();
473		}
474
475		/**
#	Line 385 | Line 477 | public class CountedCompleterTest extend
477		* zero else null
478		*/
479		public void testNextComplete() {
480	<	NoopCountedCompleter a = new NoopCountedCompleter();
481	<	NoopCountedCompleter b = new NoopCountedCompleter(a);
480	>	NoopCC a = new NoopCC();
481	>	NoopCC b = new NoopCC(a);
482		a.setPendingCount(1);
483		b.setPendingCount(1);
484		assertNull(b.firstComplete());
485	<	CountedCompleter c = b.firstComplete();
486	<	assertEquals(b, c);
487	<	CountedCompleter d = c.nextComplete();
488	<	assertNull(d);
489	<	CountedCompleter e = c.nextComplete();
490	<	assertEquals(a, e);
485	>	assertSame(b, b.firstComplete());
486	>	assertNull(b.nextComplete());
487	>	a.checkIncomplete();
488	>	b.checkIncomplete();
489	>	assertSame(a, b.nextComplete());
490	>	assertSame(a, b.nextComplete());
491	>	a.checkIncomplete();
492	>	b.checkIncomplete();
493	>	assertNull(a.nextComplete());
494	>	b.checkIncomplete();
495	>	checkCompletedNormally(a);
496		}
497
498		/**
499	<	* quietlyCompleteRoot completes root task
499	>	* quietlyCompleteRoot completes root task and only root task
500		*/
501		public void testQuietlyCompleteRoot() {
502	<	NoopCountedCompleter a = new NoopCountedCompleter();
503	<	NoopCountedCompleter b = new NoopCountedCompleter(a);
502	>	NoopCC a = new NoopCC();
503	>	NoopCC b = new NoopCC(a);
504	>	NoopCC c = new NoopCC(b);
505		a.setPendingCount(1);
506		b.setPendingCount(1);
507	<	b.quietlyCompleteRoot();
507	>	c.setPendingCount(1);
508	>	c.quietlyCompleteRoot();
509		assertTrue(a.isDone());
510		assertFalse(b.isDone());
511	+	assertFalse(c.isDone());
512		}
513
514		// Invocation tests use some interdependent task classes
515		// to better test propagation etc
516
517	<
518	<	// Version of Fibonacci with different classes for left vs right forks
519	<	static abstract class CCF extends CountedCompleter {
517	>	/**
518	>	* Version of Fibonacci with different classes for left vs right forks
519	>	*/
520	>	abstract class CCF extends CheckedCC {
521		int number;
522		int rnumber;
523
#	Line 425 | Line 526 | public class CountedCompleterTest extend
526		this.number = n;
527		}
528
529	<	public final void compute() {
429	<	CountedCompleter p;
529	>	protected final void realCompute() {
530		CCF f = this;
531		int n = number;
532		while (n >= 2) {
533		new RCCF(f, n - 2).fork();
534		f = new LCCF(f, --n);
535		}
536	<	f.number = n;
437	<	f.onCompletion(f);
438	<	if ((p = f.getCompleter()) != null)
439	<	p.tryComplete();
440	<	else
441	<	f.quietlyComplete();
536	>	f.complete(null);
537		}
538		}
539
540	<	static final class LCCF extends CCF {
540	>	final class LCCF extends CCF {
541	>	public LCCF(int n) { this(null, n); }
542		public LCCF(CountedCompleter parent, int n) {
543		super(parent, n);
544		}
545		public final void onCompletion(CountedCompleter caller) {
546	+	super.onCompletion(caller);
547		CCF p = (CCF)getCompleter();
548		int n = number + rnumber;
549		if (p != null)
#	Line 455 | Line 552 | public class CountedCompleterTest extend
552		number = n;
553		}
554		}
555	<	static final class RCCF extends CCF {
555	>	final class RCCF extends CCF {
556		public RCCF(CountedCompleter parent, int n) {
557		super(parent, n);
558		}
559		public final void onCompletion(CountedCompleter caller) {
560	+	super.onCompletion(caller);
561		CCF p = (CCF)getCompleter();
562		int n = number + rnumber;
563		if (p != null)
#	Line 470 | Line 568 | public class CountedCompleterTest extend
568		}
569
570		// Version of CCF with forced failure in left completions
571	<	static abstract class FailingCCF extends CountedCompleter {
571	>	abstract class FailingCCF extends CheckedCC {
572		int number;
573		int rnumber;
574
#	Line 479 | Line 577 | public class CountedCompleterTest extend
577		this.number = n;
578		}
579
580	<	public final void compute() {
483	<	CountedCompleter p;
580	>	protected final void realCompute() {
581		FailingCCF f = this;
582		int n = number;
583		while (n >= 2) {
584		new RFCCF(f, n - 2).fork();
585		f = new LFCCF(f, --n);
586		}
587	<	f.number = n;
491	<	f.onCompletion(f);
492	<	if ((p = f.getCompleter()) != null)
493	<	p.tryComplete();
494	<	else
495	<	f.quietlyComplete();
587	>	f.complete(null);
588		}
589		}
590
591	<	static final class LFCCF extends FailingCCF {
591	>	final class LFCCF extends FailingCCF {
592	>	public LFCCF(int n) { this(null, n); }
593		public LFCCF(CountedCompleter parent, int n) {
594		super(parent, n);
595		}
596		public final void onCompletion(CountedCompleter caller) {
597	+	super.onCompletion(caller);
598		FailingCCF p = (FailingCCF)getCompleter();
599		int n = number + rnumber;
600		if (p != null)
#	Line 509 | Line 603 | public class CountedCompleterTest extend
603		number = n;
604		}
605		}
606	<	static final class RFCCF extends FailingCCF {
606	>	final class RFCCF extends FailingCCF {
607		public RFCCF(CountedCompleter parent, int n) {
608		super(parent, n);
609		}
610		public final void onCompletion(CountedCompleter caller) {
611	+	super.onCompletion(caller);
612		completeExceptionally(new FJException());
613		}
614		}
615	<
615	>
616		/**
617		* invoke returns when task completes normally.
618		* isCompletedAbnormally and isCancelled return false for normally
619		* completed tasks; getRawResult returns null.
620		*/
621		public void testInvoke() {
622	<	ForkJoinTask a =  new CheckedFJTask() {
623	<	public void realCompute() {
624	<	CCF f = new LCCF(null, 8);
622	>	ForkJoinTask a = new CheckedRecursiveAction() {
623	>	protected void realCompute() {
624	>	CCF f = new LCCF(8);
625		assertNull(f.invoke());
626		assertEquals(21, f.number);
627		checkCompletedNormally(f);
#	Line 540 | Line 635 | public class CountedCompleterTest extend
635		* completed tasks
636		*/
637		public void testQuietlyInvoke() {
638	<	ForkJoinTask a =  new CheckedFJTask() {
639	<	public void realCompute() {
640	<	CCF f = new LCCF(null, 8);
638	>	ForkJoinTask a = new CheckedRecursiveAction() {
639	>	protected void realCompute() {
640	>	CCF f = new LCCF(8);
641		f.quietlyInvoke();
642		assertEquals(21, f.number);
643		checkCompletedNormally(f);
#	Line 554 | Line 649 | public class CountedCompleterTest extend
649		* join of a forked task returns when task completes
650		*/
651		public void testForkJoin() {
652	<	ForkJoinTask a =  new CheckedFJTask() {
653	<	public void realCompute() {
654	<	CCF f = new LCCF(null, 8);
652	>	ForkJoinTask a = new CheckedRecursiveAction() {
653	>	protected void realCompute() {
654	>	CCF f = new LCCF(8);
655		assertSame(f, f.fork());
656		assertNull(f.join());
657		assertEquals(21, f.number);
#	Line 569 | Line 664 | public class CountedCompleterTest extend
664		* get of a forked task returns when task completes
665		*/
666		public void testForkGet() {
667	<	ForkJoinTask a =  new CheckedFJTask() {
668	<	public void realCompute() throws Exception {
669	<	CCF f = new LCCF(null, 8);
667	>	ForkJoinTask a = new CheckedRecursiveAction() {
668	>	protected void realCompute() throws Exception {
669	>	CCF f = new LCCF(8);
670		assertSame(f, f.fork());
671		assertNull(f.get());
672		assertEquals(21, f.number);
#	Line 584 | Line 679 | public class CountedCompleterTest extend
679		* timed get of a forked task returns when task completes
680		*/
681		public void testForkTimedGet() {
682	<	ForkJoinTask a =  new CheckedFJTask() {
683	<	public void realCompute() throws Exception {
684	<	CCF f = new LCCF(null, 8);
682	>	ForkJoinTask a = new CheckedRecursiveAction() {
683	>	protected void realCompute() throws Exception {
684	>	CCF f = new LCCF(8);
685		assertSame(f, f.fork());
686		assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
687		assertEquals(21, f.number);
#	Line 599 | Line 694 | public class CountedCompleterTest extend
694		* timed get with null time unit throws NPE
695		*/
696		public void testForkTimedGetNPE() {
697	<	ForkJoinTask a =  new CheckedFJTask() {
698	<	public void realCompute() throws Exception {
699	<	CCF f = new LCCF(null, 8);
697	>	ForkJoinTask a = new CheckedRecursiveAction() {
698	>	protected void realCompute() throws Exception {
699	>	CCF f = new LCCF(8);
700		assertSame(f, f.fork());
701		try {
702	<	f.get(5L, null);
702	>	f.get(randomTimeout(), null);
703		shouldThrow();
704		} catch (NullPointerException success) {}
705		}};
#	Line 615 | Line 710 | public class CountedCompleterTest extend
710		* quietlyJoin of a forked task returns when task completes
711		*/
712		public void testForkQuietlyJoin() {
713	<	ForkJoinTask a =  new CheckedFJTask() {
714	<	public void realCompute() {
715	<	CCF f = new LCCF(null, 8);
713	>	ForkJoinTask a = new CheckedRecursiveAction() {
714	>	protected void realCompute() {
715	>	CCF f = new LCCF(8);
716		assertSame(f, f.fork());
717		f.quietlyJoin();
718		assertEquals(21, f.number);
#	Line 631 | Line 726 | public class CountedCompleterTest extend
726		* getQueuedTaskCount returns 0 when quiescent
727		*/
728		public void testForkHelpQuiesce() {
729	<	ForkJoinTask a =  new CheckedFJTask() {
730	<	public void realCompute() {
731	<	CCF f = new LCCF(null, 8);
729	>	ForkJoinTask a = new CheckedRecursiveAction() {
730	>	protected void realCompute() {
731	>	CCF f = new LCCF(8);
732		assertSame(f, f.fork());
733		helpQuiesce();
734		assertEquals(21, f.number);
#	Line 647 | Line 742 | public class CountedCompleterTest extend
742		* invoke task throws exception when task completes abnormally
743		*/
744		public void testAbnormalInvoke() {
745	<	ForkJoinTask a =  new CheckedFJTask() {
746	<	public void realCompute() {
747	<	FailingCCF f = new LFCCF(null, 8);
745	>	ForkJoinTask a = new CheckedRecursiveAction() {
746	>	protected void realCompute() {
747	>	FailingCCF f = new LFCCF(8);
748		try {
749		f.invoke();
750		shouldThrow();
#	Line 664 | Line 759 | public class CountedCompleterTest extend
759		* quietlyInvoke task returns when task completes abnormally
760		*/
761		public void testAbnormalQuietlyInvoke() {
762	<	ForkJoinTask a =  new CheckedFJTask() {
763	<	public void realCompute() {
764	<	FailingCCF f = new LFCCF(null, 8);
762	>	ForkJoinTask a = new CheckedRecursiveAction() {
763	>	protected void realCompute() {
764	>	FailingCCF f = new LFCCF(8);
765		f.quietlyInvoke();
766		assertTrue(f.getException() instanceof FJException);
767		checkCompletedAbnormally(f, f.getException());
#	Line 678 | Line 773 | public class CountedCompleterTest extend
773		* join of a forked task throws exception when task completes abnormally
774		*/
775		public void testAbnormalForkJoin() {
776	<	ForkJoinTask a =  new CheckedFJTask() {
777	<	public void realCompute() {
778	<	FailingCCF f = new LFCCF(null, 8);
776	>	ForkJoinTask a = new CheckedRecursiveAction() {
777	>	protected void realCompute() {
778	>	FailingCCF f = new LFCCF(8);
779		assertSame(f, f.fork());
780		try {
781		f.join();
#	Line 696 | Line 791 | public class CountedCompleterTest extend
791		* get of a forked task throws exception when task completes abnormally
792		*/
793		public void testAbnormalForkGet() {
794	<	ForkJoinTask a =  new CheckedFJTask() {
795	<	public void realCompute() throws Exception {
796	<	FailingCCF f = new LFCCF(null, 8);
794	>	ForkJoinTask a = new CheckedRecursiveAction() {
795	>	protected void realCompute() throws Exception {
796	>	FailingCCF f = new LFCCF(8);
797		assertSame(f, f.fork());
798		try {
799		f.get();
#	Line 716 | Line 811 | public class CountedCompleterTest extend
811		* timed get of a forked task throws exception when task completes abnormally
812		*/
813		public void testAbnormalForkTimedGet() {
814	<	ForkJoinTask a =  new CheckedFJTask() {
815	<	public void realCompute() throws Exception {
816	<	FailingCCF f = new LFCCF(null, 8);
814	>	ForkJoinTask a = new CheckedRecursiveAction() {
815	>	protected void realCompute() throws Exception {
816	>	FailingCCF f = new LFCCF(8);
817		assertSame(f, f.fork());
818		try {
819		f.get(LONG_DELAY_MS, MILLISECONDS);
#	Line 736 | Line 831 | public class CountedCompleterTest extend
831		* quietlyJoin of a forked task returns when task completes abnormally
832		*/
833		public void testAbnormalForkQuietlyJoin() {
834	<	ForkJoinTask a =  new CheckedFJTask() {
835	<	public void realCompute() {
836	<	FailingCCF f = new LFCCF(null, 8);
834	>	ForkJoinTask a = new CheckedRecursiveAction() {
835	>	protected void realCompute() {
836	>	FailingCCF f = new LFCCF(8);
837		assertSame(f, f.fork());
838		f.quietlyJoin();
839		assertTrue(f.getException() instanceof FJException);
#	Line 751 | Line 846 | public class CountedCompleterTest extend
846		* invoke task throws exception when task cancelled
847		*/
848		public void testCancelledInvoke() {
849	<	ForkJoinTask a =  new CheckedFJTask() {
850	<	public void realCompute() {
851	<	CCF f = new LCCF(null, 8);
849	>	ForkJoinTask a = new CheckedRecursiveAction() {
850	>	protected void realCompute() {
851	>	CCF f = new LCCF(8);
852		assertTrue(f.cancel(true));
853		try {
854		f.invoke();
#	Line 769 | Line 864 | public class CountedCompleterTest extend
864		* join of a forked task throws exception when task cancelled
865		*/
866		public void testCancelledForkJoin() {
867	<	ForkJoinTask a =  new CheckedFJTask() {
868	<	public void realCompute() {
869	<	CCF f = new LCCF(null, 8);
867	>	ForkJoinTask a = new CheckedRecursiveAction() {
868	>	protected void realCompute() {
869	>	CCF f = new LCCF(8);
870		assertTrue(f.cancel(true));
871		assertSame(f, f.fork());
872		try {
#	Line 788 | Line 883 | public class CountedCompleterTest extend
883		* get of a forked task throws exception when task cancelled
884		*/
885		public void testCancelledForkGet() {
886	<	ForkJoinTask a =  new CheckedFJTask() {
887	<	public void realCompute() throws Exception {
888	<	CCF f = new LCCF(null, 8);
886	>	ForkJoinTask a = new CheckedRecursiveAction() {
887	>	protected void realCompute() throws Exception {
888	>	CCF f = new LCCF(8);
889		assertTrue(f.cancel(true));
890		assertSame(f, f.fork());
891		try {
#	Line 807 | Line 902 | public class CountedCompleterTest extend
902		* timed get of a forked task throws exception when task cancelled
903		*/
904		public void testCancelledForkTimedGet() throws Exception {
905	<	ForkJoinTask a =  new CheckedFJTask() {
906	<	public void realCompute() throws Exception {
907	<	CCF f = new LCCF(null, 8);
905	>	ForkJoinTask a = new CheckedRecursiveAction() {
906	>	protected void realCompute() throws Exception {
907	>	CCF f = new LCCF(8);
908		assertTrue(f.cancel(true));
909		assertSame(f, f.fork());
910		try {
#	Line 826 | Line 921 | public class CountedCompleterTest extend
921		* quietlyJoin of a forked task returns when task cancelled
922		*/
923		public void testCancelledForkQuietlyJoin() {
924	<	ForkJoinTask a =  new CheckedFJTask() {
925	<	public void realCompute() {
926	<	CCF f = new LCCF(null, 8);
924	>	ForkJoinTask a = new CheckedRecursiveAction() {
925	>	protected void realCompute() {
926	>	CCF f = new LCCF(8);
927		assertTrue(f.cancel(true));
928		assertSame(f, f.fork());
929		f.quietlyJoin();
#	Line 842 | Line 937 | public class CountedCompleterTest extend
937		*/
938		public void testGetPool() {
939		final ForkJoinPool mainPool = mainPool();
940	<	ForkJoinTask a =  new CheckedFJTask() {
941	<	public void realCompute() {
940	>	ForkJoinTask a = new CheckedRecursiveAction() {
941	>	protected void realCompute() {
942		assertSame(mainPool, getPool());
943		}};
944		testInvokeOnPool(mainPool, a);
#	Line 853 | Line 948 | public class CountedCompleterTest extend
948		* getPool of non-FJ task returns null
949		*/
950		public void testGetPool2() {
951	<	ForkJoinTask a =  new CheckedFJTask() {
952	<	public void realCompute() {
951	>	ForkJoinTask a = new CheckedRecursiveAction() {
952	>	protected void realCompute() {
953		assertNull(getPool());
954		}};
955		assertNull(a.invoke());
#	Line 864 | Line 959 | public class CountedCompleterTest extend
959		* inForkJoinPool of executing task returns true
960		*/
961		public void testInForkJoinPool() {
962	<	ForkJoinTask a =  new CheckedFJTask() {
963	<	public void realCompute() {
962	>	ForkJoinTask a = new CheckedRecursiveAction() {
963	>	protected void realCompute() {
964		assertTrue(inForkJoinPool());
965		}};
966		testInvokeOnPool(mainPool(), a);
#	Line 875 | Line 970 | public class CountedCompleterTest extend
970		* inForkJoinPool of non-FJ task returns false
971		*/
972		public void testInForkJoinPool2() {
973	<	ForkJoinTask a =  new CheckedFJTask() {
974	<	public void realCompute() {
973	>	ForkJoinTask a = new CheckedRecursiveAction() {
974	>	protected void realCompute() {
975		assertFalse(inForkJoinPool());
976		}};
977		assertNull(a.invoke());
#	Line 886 | Line 981 | public class CountedCompleterTest extend
981		* setRawResult(null) succeeds
982		*/
983		public void testSetRawResult() {
984	<	ForkJoinTask a =  new CheckedFJTask() {
985	<	public void realCompute() {
984	>	ForkJoinTask a = new CheckedRecursiveAction() {
985	>	protected void realCompute() {
986		setRawResult(null);
987		assertNull(getRawResult());
988		}};
#	Line 898 | Line 993 | public class CountedCompleterTest extend
993		* invoke task throws exception after invoking completeExceptionally
994		*/
995		public void testCompleteExceptionally2() {
996	<	ForkJoinTask a =  new CheckedFJTask() {
997	<	public void realCompute() {
998	<	CCF f = new LCCF(null, 8);
999	<	f.completeExceptionally(new FJException());
1000	<	try {
1001	<	f.invoke();
1002	<	shouldThrow();
1003	<	} catch (FJException success) {
909	<	checkCompletedAbnormally(f, success);
910	<	}
996	>	ForkJoinTask a = new CheckedRecursiveAction() {
997	>	protected void realCompute() {
998	>	CCF n = new LCCF(8);
999	>	CCF f = new LCCF(n, 8);
1000	>	FJException ex = new FJException();
1001	>	f.completeExceptionally(ex);
1002	>	f.checkCompletedExceptionally(ex);
1003	>	n.checkCompletedExceptionally(ex);
1004		}};
1005		testInvokeOnPool(mainPool(), a);
1006		}
#	Line 916 | Line 1009 | public class CountedCompleterTest extend
1009		* invokeAll(t1, t2) invokes all task arguments
1010		*/
1011		public void testInvokeAll2() {
1012	<	ForkJoinTask a =  new CheckedFJTask() {
1013	<	public void realCompute() {
1014	<	CCF f = new LCCF(null, 8);
1015	<	CCF g = new LCCF(null, 9);
1012	>	ForkJoinTask a = new CheckedRecursiveAction() {
1013	>	protected void realCompute() {
1014	>	CCF f = new LCCF(8);
1015	>	CCF g = new LCCF(9);
1016		invokeAll(f, g);
1017		assertEquals(21, f.number);
1018		assertEquals(34, g.number);
#	Line 933 | Line 1026 | public class CountedCompleterTest extend
1026		* invokeAll(tasks) with 1 argument invokes task
1027		*/
1028		public void testInvokeAll1() {
1029	<	ForkJoinTask a =  new CheckedFJTask() {
1030	<	public void realCompute() {
1031	<	CCF f = new LCCF(null, 8);
1029	>	ForkJoinTask a = new CheckedRecursiveAction() {
1030	>	protected void realCompute() {
1031	>	CCF f = new LCCF(8);
1032		invokeAll(f);
1033		checkCompletedNormally(f);
1034		assertEquals(21, f.number);
#	Line 947 | Line 1040 | public class CountedCompleterTest extend
1040		* invokeAll(tasks) with > 2 argument invokes tasks
1041		*/
1042		public void testInvokeAll3() {
1043	<	ForkJoinTask a =  new CheckedFJTask() {
1044	<	public void realCompute() {
1045	<	CCF f = new LCCF(null, 8);
1046	<	CCF g = new LCCF(null, 9);
1047	<	CCF h = new LCCF(null, 7);
1043	>	ForkJoinTask a = new CheckedRecursiveAction() {
1044	>	protected void realCompute() {
1045	>	CCF f = new LCCF(8);
1046	>	CCF g = new LCCF(9);
1047	>	CCF h = new LCCF(7);
1048		invokeAll(f, g, h);
1049		assertEquals(21, f.number);
1050		assertEquals(34, g.number);
#	Line 967 | Line 1060 | public class CountedCompleterTest extend
1060		* invokeAll(collection) invokes all tasks in the collection
1061		*/
1062		public void testInvokeAllCollection() {
1063	<	ForkJoinTask a =  new CheckedFJTask() {
1064	<	public void realCompute() {
1065	<	CCF f = new LCCF(null, 8);
1066	<	CCF g = new LCCF(null, 9);
1067	<	CCF h = new LCCF(null, 7);
1063	>	ForkJoinTask a = new CheckedRecursiveAction() {
1064	>	protected void realCompute() {
1065	>	CCF f = new LCCF(8);
1066	>	CCF g = new LCCF(9);
1067	>	CCF h = new LCCF(7);
1068		HashSet set = new HashSet();
1069		set.add(f);
1070		set.add(g);
#	Line 991 | Line 1084 | public class CountedCompleterTest extend
1084		* invokeAll(tasks) with any null task throws NPE
1085		*/
1086		public void testInvokeAllNPE() {
1087	<	ForkJoinTask a =  new CheckedFJTask() {
1088	<	public void realCompute() {
1089	<	CCF f = new LCCF(null, 8);
1090	<	CCF g = new LCCF(null, 9);
1087	>	ForkJoinTask a = new CheckedRecursiveAction() {
1088	>	protected void realCompute() {
1089	>	CCF f = new LCCF(8);
1090	>	CCF g = new LCCF(9);
1091		CCF h = null;
1092		try {
1093		invokeAll(f, g, h);
#	Line 1008 | Line 1101 | public class CountedCompleterTest extend
1101		* invokeAll(t1, t2) throw exception if any task does
1102		*/
1103		public void testAbnormalInvokeAll2() {
1104	<	ForkJoinTask a =  new CheckedFJTask() {
1105	<	public void realCompute() {
1106	<	CCF f = new LCCF(null, 8);
1107	<	FailingCCF g = new LFCCF(null, 9);
1104	>	ForkJoinTask a = new CheckedRecursiveAction() {
1105	>	protected void realCompute() {
1106	>	CCF f = new LCCF(8);
1107	>	FailingCCF g = new LFCCF(9);
1108		try {
1109		invokeAll(f, g);
1110		shouldThrow();
#	Line 1026 | Line 1119 | public class CountedCompleterTest extend
1119		* invokeAll(tasks) with 1 argument throws exception if task does
1120		*/
1121		public void testAbnormalInvokeAll1() {
1122	<	ForkJoinTask a =  new CheckedFJTask() {
1123	<	public void realCompute() {
1124	<	FailingCCF g = new LFCCF(null, 9);
1122	>	ForkJoinTask a = new CheckedRecursiveAction() {
1123	>	protected void realCompute() {
1124	>	FailingCCF g = new LFCCF(9);
1125		try {
1126		invokeAll(g);
1127		shouldThrow();
#	Line 1043 | Line 1136 | public class CountedCompleterTest extend
1136		* invokeAll(tasks) with > 2 argument throws exception if any task does
1137		*/
1138		public void testAbnormalInvokeAll3() {
1139	<	ForkJoinTask a =  new CheckedFJTask() {
1140	<	public void realCompute() {
1141	<	CCF f = new LCCF(null, 8);
1142	<	FailingCCF g = new LFCCF(null, 9);
1143	<	CCF h = new LCCF(null, 7);
1139	>	ForkJoinTask a = new CheckedRecursiveAction() {
1140	>	protected void realCompute() {
1141	>	CCF f = new LCCF(8);
1142	>	FailingCCF g = new LFCCF(9);
1143	>	CCF h = new LCCF(7);
1144		try {
1145		invokeAll(f, g, h);
1146		shouldThrow();
#	Line 1059 | Line 1152 | public class CountedCompleterTest extend
1152		}
1153
1154		/**
1155	<	* invokeAll(collection)  throws exception if any task does
1155	>	* invokeAll(collection) throws exception if any task does
1156		*/
1157		public void testAbnormalInvokeAllCollection() {
1158	<	ForkJoinTask a =  new CheckedFJTask() {
1159	<	public void realCompute() {
1160	<	FailingCCF f = new LFCCF(null, 8);
1161	<	CCF g = new LCCF(null, 9);
1162	<	CCF h = new LCCF(null, 7);
1158	>	ForkJoinTask a = new CheckedRecursiveAction() {
1159	>	protected void realCompute() {
1160	>	FailingCCF f = new LFCCF(8);
1161	>	CCF g = new LCCF(9);
1162	>	CCF h = new LCCF(7);
1163		HashSet set = new HashSet();
1164		set.add(f);
1165		set.add(g);
#	Line 1086 | Line 1179 | public class CountedCompleterTest extend
1179		* and suppresses execution
1180		*/
1181		public void testTryUnfork() {
1182	<	ForkJoinTask a =  new CheckedFJTask() {
1183	<	public void realCompute() {
1184	<	CCF g = new LCCF(null, 9);
1182	>	ForkJoinTask a = new CheckedRecursiveAction() {
1183	>	protected void realCompute() {
1184	>	CCF g = new LCCF(9);
1185		assertSame(g, g.fork());
1186	<	CCF f = new LCCF(null, 8);
1186	>	CCF f = new LCCF(8);
1187		assertSame(f, f.fork());
1188		assertTrue(f.tryUnfork());
1189		helpQuiesce();
#	Line 1105 | Line 1198 | public class CountedCompleterTest extend
1198		* there are more tasks than threads
1199		*/
1200		public void testGetSurplusQueuedTaskCount() {
1201	<	ForkJoinTask a =  new CheckedFJTask() {
1202	<	public void realCompute() {
1203	<	CCF h = new LCCF(null, 7);
1201	>	ForkJoinTask a = new CheckedRecursiveAction() {
1202	>	protected void realCompute() {
1203	>	CCF h = new LCCF(7);
1204		assertSame(h, h.fork());
1205	<	CCF g = new LCCF(null, 9);
1205	>	CCF g = new LCCF(9);
1206		assertSame(g, g.fork());
1207	<	CCF f = new LCCF(null, 8);
1207	>	CCF f = new LCCF(8);
1208		assertSame(f, f.fork());
1209		assertTrue(getSurplusQueuedTaskCount() > 0);
1210		helpQuiesce();
#	Line 1127 | Line 1220 | public class CountedCompleterTest extend
1220		* peekNextLocalTask returns most recent unexecuted task.
1221		*/
1222		public void testPeekNextLocalTask() {
1223	<	ForkJoinTask a =  new CheckedFJTask() {
1224	<	public void realCompute() {
1225	<	CCF g = new LCCF(null, 9);
1223	>	ForkJoinTask a = new CheckedRecursiveAction() {
1224	>	protected void realCompute() {
1225	>	CCF g = new LCCF(9);
1226		assertSame(g, g.fork());
1227	<	CCF f = new LCCF(null, 8);
1227	>	CCF f = new LCCF(8);
1228		assertSame(f, f.fork());
1229		assertSame(f, peekNextLocalTask());
1230		assertNull(f.join());
#	Line 1147 | Line 1240 | public class CountedCompleterTest extend
1240		* executing it
1241		*/
1242		public void testPollNextLocalTask() {
1243	<	ForkJoinTask a =  new CheckedFJTask() {
1244	<	public void realCompute() {
1245	<	CCF g = new LCCF(null, 9);
1243	>	ForkJoinTask a = new CheckedRecursiveAction() {
1244	>	protected void realCompute() {
1245	>	CCF g = new LCCF(9);
1246		assertSame(g, g.fork());
1247	<	CCF f = new LCCF(null, 8);
1247	>	CCF f = new LCCF(8);
1248		assertSame(f, f.fork());
1249		assertSame(f, pollNextLocalTask());
1250		helpQuiesce();
#	Line 1166 | Line 1259 | public class CountedCompleterTest extend
1259		* pollTask returns an unexecuted task without executing it
1260		*/
1261		public void testPollTask() {
1262	<	ForkJoinTask a =  new CheckedFJTask() {
1263	<	public void realCompute() {
1264	<	CCF g = new LCCF(null, 9);
1262	>	ForkJoinTask a = new CheckedRecursiveAction() {
1263	>	protected void realCompute() {
1264	>	CCF g = new LCCF(9);
1265		assertSame(g, g.fork());
1266	<	CCF f = new LCCF(null, 8);
1266	>	CCF f = new LCCF(8);
1267		assertSame(f, f.fork());
1268		assertSame(f, pollTask());
1269		helpQuiesce();
#	Line 1184 | Line 1277 | public class CountedCompleterTest extend
1277		* peekNextLocalTask returns least recent unexecuted task in async mode
1278		*/
1279		public void testPeekNextLocalTaskAsync() {
1280	<	ForkJoinTask a =  new CheckedFJTask() {
1281	<	public void realCompute() {
1282	<	CCF g = new LCCF(null, 9);
1280	>	ForkJoinTask a = new CheckedRecursiveAction() {
1281	>	protected void realCompute() {
1282	>	CCF g = new LCCF(9);
1283		assertSame(g, g.fork());
1284	<	CCF f = new LCCF(null, 8);
1284	>	CCF f = new LCCF(8);
1285		assertSame(f, f.fork());
1286		assertSame(g, peekNextLocalTask());
1287		assertNull(f.join());
#	Line 1205 | Line 1298 | public class CountedCompleterTest extend
1298		* executing it, in async mode
1299		*/
1300		public void testPollNextLocalTaskAsync() {
1301	<	ForkJoinTask a =  new CheckedFJTask() {
1302	<	public void realCompute() {
1303	<	CCF g = new LCCF(null, 9);
1301	>	ForkJoinTask a = new CheckedRecursiveAction() {
1302	>	protected void realCompute() {
1303	>	CCF g = new LCCF(9);
1304		assertSame(g, g.fork());
1305	<	CCF f = new LCCF(null, 8);
1305	>	CCF f = new LCCF(8);
1306		assertSame(f, f.fork());
1307		assertSame(g, pollNextLocalTask());
1308		helpQuiesce();
#	Line 1225 | Line 1318 | public class CountedCompleterTest extend
1318		* async mode
1319		*/
1320		public void testPollTaskAsync() {
1321	<	ForkJoinTask a =  new CheckedFJTask() {
1322	<	public void realCompute() {
1323	<	CCF g = new LCCF(null, 9);
1321	>	ForkJoinTask a = new CheckedRecursiveAction() {
1322	>	protected void realCompute() {
1323	>	CCF g = new LCCF(9);
1324		assertSame(g, g.fork());
1325	<	CCF f = new LCCF(null, 8);
1325	>	CCF f = new LCCF(8);
1326		assertSame(f, f.fork());
1327		assertSame(g, pollTask());
1328		helpQuiesce();
#	Line 1248 | Line 1341 | public class CountedCompleterTest extend
1341		* completed tasks; getRawResult returns null.
1342		*/
1343		public void testInvokeSingleton() {
1344	<	ForkJoinTask a =  new CheckedFJTask() {
1345	<	public void realCompute() {
1346	<	CCF f = new LCCF(null, 8);
1344	>	ForkJoinTask a = new CheckedRecursiveAction() {
1345	>	protected void realCompute() {
1346	>	CCF f = new LCCF(8);
1347		assertNull(f.invoke());
1348		assertEquals(21, f.number);
1349		checkCompletedNormally(f);
#	Line 1264 | Line 1357 | public class CountedCompleterTest extend
1357		* completed tasks
1358		*/
1359		public void testQuietlyInvokeSingleton() {
1360	<	ForkJoinTask a =  new CheckedFJTask() {
1361	<	public void realCompute() {
1362	<	CCF f = new LCCF(null, 8);
1360	>	ForkJoinTask a = new CheckedRecursiveAction() {
1361	>	protected void realCompute() {
1362	>	CCF f = new LCCF(8);
1363		f.quietlyInvoke();
1364		assertEquals(21, f.number);
1365		checkCompletedNormally(f);
#	Line 1278 | Line 1371 | public class CountedCompleterTest extend
1371		* join of a forked task returns when task completes
1372		*/
1373		public void testForkJoinSingleton() {
1374	<	ForkJoinTask a =  new CheckedFJTask() {
1375	<	public void realCompute() {
1376	<	CCF f = new LCCF(null, 8);
1374	>	ForkJoinTask a = new CheckedRecursiveAction() {
1375	>	protected void realCompute() {
1376	>	CCF f = new LCCF(8);
1377		assertSame(f, f.fork());
1378		assertNull(f.join());
1379		assertEquals(21, f.number);
#	Line 1293 | Line 1386 | public class CountedCompleterTest extend
1386		* get of a forked task returns when task completes
1387		*/
1388		public void testForkGetSingleton() {
1389	<	ForkJoinTask a =  new CheckedFJTask() {
1390	<	public void realCompute() throws Exception {
1391	<	CCF f = new LCCF(null, 8);
1389	>	ForkJoinTask a = new CheckedRecursiveAction() {
1390	>	protected void realCompute() throws Exception {
1391	>	CCF f = new LCCF(8);
1392		assertSame(f, f.fork());
1393		assertNull(f.get());
1394		assertEquals(21, f.number);
#	Line 1308 | Line 1401 | public class CountedCompleterTest extend
1401		* timed get of a forked task returns when task completes
1402		*/
1403		public void testForkTimedGetSingleton() {
1404	<	ForkJoinTask a =  new CheckedFJTask() {
1405	<	public void realCompute() throws Exception {
1406	<	CCF f = new LCCF(null, 8);
1404	>	ForkJoinTask a = new CheckedRecursiveAction() {
1405	>	protected void realCompute() throws Exception {
1406	>	CCF f = new LCCF(8);
1407		assertSame(f, f.fork());
1408		assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
1409		assertEquals(21, f.number);
#	Line 1323 | Line 1416 | public class CountedCompleterTest extend
1416		* timed get with null time unit throws NPE
1417		*/
1418		public void testForkTimedGetNPESingleton() {
1419	<	ForkJoinTask a =  new CheckedFJTask() {
1420	<	public void realCompute() throws Exception {
1421	<	CCF f = new LCCF(null, 8);
1419	>	ForkJoinTask a = new CheckedRecursiveAction() {
1420	>	protected void realCompute() throws Exception {
1421	>	CCF f = new LCCF(8);
1422		assertSame(f, f.fork());
1423		try {
1424	<	f.get(5L, null);
1424	>	f.get(randomTimeout(), null);
1425		shouldThrow();
1426		} catch (NullPointerException success) {}
1427		}};
#	Line 1339 | Line 1432 | public class CountedCompleterTest extend
1432		* quietlyJoin of a forked task returns when task completes
1433		*/
1434		public void testForkQuietlyJoinSingleton() {
1435	<	ForkJoinTask a =  new CheckedFJTask() {
1436	<	public void realCompute() {
1437	<	CCF f = new LCCF(null, 8);
1435	>	ForkJoinTask a = new CheckedRecursiveAction() {
1436	>	protected void realCompute() {
1437	>	CCF f = new LCCF(8);
1438		assertSame(f, f.fork());
1439		f.quietlyJoin();
1440		assertEquals(21, f.number);
#	Line 1355 | Line 1448 | public class CountedCompleterTest extend
1448		* getQueuedTaskCount returns 0 when quiescent
1449		*/
1450		public void testForkHelpQuiesceSingleton() {
1451	<	ForkJoinTask a =  new CheckedFJTask() {
1452	<	public void realCompute() {
1453	<	CCF f = new LCCF(null, 8);
1451	>	ForkJoinTask a = new CheckedRecursiveAction() {
1452	>	protected void realCompute() {
1453	>	CCF f = new LCCF(8);
1454		assertSame(f, f.fork());
1455		helpQuiesce();
1456		assertEquals(0, getQueuedTaskCount());
#	Line 1371 | Line 1464 | public class CountedCompleterTest extend
1464		* invoke task throws exception when task completes abnormally
1465		*/
1466		public void testAbnormalInvokeSingleton() {
1467	<	ForkJoinTask a =  new CheckedFJTask() {
1468	<	public void realCompute() {
1469	<	FailingCCF f = new LFCCF(null, 8);
1467	>	ForkJoinTask a = new CheckedRecursiveAction() {
1468	>	protected void realCompute() {
1469	>	FailingCCF f = new LFCCF(8);
1470		try {
1471		f.invoke();
1472		shouldThrow();
#	Line 1388 | Line 1481 | public class CountedCompleterTest extend
1481		* quietlyInvoke task returns when task completes abnormally
1482		*/
1483		public void testAbnormalQuietlyInvokeSingleton() {
1484	<	ForkJoinTask a =  new CheckedFJTask() {
1485	<	public void realCompute() {
1486	<	FailingCCF f = new LFCCF(null, 8);
1484	>	ForkJoinTask a = new CheckedRecursiveAction() {
1485	>	protected void realCompute() {
1486	>	FailingCCF f = new LFCCF(8);
1487		f.quietlyInvoke();
1488		assertTrue(f.getException() instanceof FJException);
1489		checkCompletedAbnormally(f, f.getException());
#	Line 1402 | Line 1495 | public class CountedCompleterTest extend
1495		* join of a forked task throws exception when task completes abnormally
1496		*/
1497		public void testAbnormalForkJoinSingleton() {
1498	<	ForkJoinTask a =  new CheckedFJTask() {
1499	<	public void realCompute() {
1500	<	FailingCCF f = new LFCCF(null, 8);
1498	>	ForkJoinTask a = new CheckedRecursiveAction() {
1499	>	protected void realCompute() {
1500	>	FailingCCF f = new LFCCF(8);
1501		assertSame(f, f.fork());
1502		try {
1503		f.join();
#	Line 1420 | Line 1513 | public class CountedCompleterTest extend
1513		* get of a forked task throws exception when task completes abnormally
1514		*/
1515		public void testAbnormalForkGetSingleton() {
1516	<	ForkJoinTask a =  new CheckedFJTask() {
1517	<	public void realCompute() throws Exception {
1518	<	FailingCCF f = new LFCCF(null, 8);
1516	>	ForkJoinTask a = new CheckedRecursiveAction() {
1517	>	protected void realCompute() throws Exception {
1518	>	FailingCCF f = new LFCCF(8);
1519		assertSame(f, f.fork());
1520		try {
1521		f.get();
#	Line 1440 | Line 1533 | public class CountedCompleterTest extend
1533		* timed get of a forked task throws exception when task completes abnormally
1534		*/
1535		public void testAbnormalForkTimedGetSingleton() {
1536	<	ForkJoinTask a =  new CheckedFJTask() {
1537	<	public void realCompute() throws Exception {
1538	<	FailingCCF f = new LFCCF(null, 8);
1536	>	ForkJoinTask a = new CheckedRecursiveAction() {
1537	>	protected void realCompute() throws Exception {
1538	>	FailingCCF f = new LFCCF(8);
1539		assertSame(f, f.fork());
1540		try {
1541		f.get(LONG_DELAY_MS, MILLISECONDS);
#	Line 1460 | Line 1553 | public class CountedCompleterTest extend
1553		* quietlyJoin of a forked task returns when task completes abnormally
1554		*/
1555		public void testAbnormalForkQuietlyJoinSingleton() {
1556	<	ForkJoinTask a =  new CheckedFJTask() {
1557	<	public void realCompute() {
1558	<	FailingCCF f = new LFCCF(null, 8);
1556	>	ForkJoinTask a = new CheckedRecursiveAction() {
1557	>	protected void realCompute() {
1558	>	FailingCCF f = new LFCCF(8);
1559		assertSame(f, f.fork());
1560		f.quietlyJoin();
1561		assertTrue(f.getException() instanceof FJException);
#	Line 1475 | Line 1568 | public class CountedCompleterTest extend
1568		* invoke task throws exception when task cancelled
1569		*/
1570		public void testCancelledInvokeSingleton() {
1571	<	ForkJoinTask a =  new CheckedFJTask() {
1572	<	public void realCompute() {
1573	<	CCF f = new LCCF(null, 8);
1571	>	ForkJoinTask a = new CheckedRecursiveAction() {
1572	>	protected void realCompute() {
1573	>	CCF f = new LCCF(8);
1574		assertTrue(f.cancel(true));
1575		try {
1576		f.invoke();
#	Line 1493 | Line 1586 | public class CountedCompleterTest extend
1586		* join of a forked task throws exception when task cancelled
1587		*/
1588		public void testCancelledForkJoinSingleton() {
1589	<	ForkJoinTask a =  new CheckedFJTask() {
1590	<	public void realCompute() {
1591	<	CCF f = new LCCF(null, 8);
1589	>	ForkJoinTask a = new CheckedRecursiveAction() {
1590	>	protected void realCompute() {
1591	>	CCF f = new LCCF(8);
1592		assertTrue(f.cancel(true));
1593		assertSame(f, f.fork());
1594		try {
#	Line 1512 | Line 1605 | public class CountedCompleterTest extend
1605		* get of a forked task throws exception when task cancelled
1606		*/
1607		public void testCancelledForkGetSingleton() {
1608	<	ForkJoinTask a =  new CheckedFJTask() {
1609	<	public void realCompute() throws Exception {
1610	<	CCF f = new LCCF(null, 8);
1608	>	ForkJoinTask a = new CheckedRecursiveAction() {
1609	>	protected void realCompute() throws Exception {
1610	>	CCF f = new LCCF(8);
1611		assertTrue(f.cancel(true));
1612		assertSame(f, f.fork());
1613		try {
#	Line 1531 | Line 1624 | public class CountedCompleterTest extend
1624		* timed get of a forked task throws exception when task cancelled
1625		*/
1626		public void testCancelledForkTimedGetSingleton() throws Exception {
1627	<	ForkJoinTask a =  new CheckedFJTask() {
1628	<	public void realCompute() throws Exception {
1629	<	CCF f = new LCCF(null, 8);
1627	>	ForkJoinTask a = new CheckedRecursiveAction() {
1628	>	protected void realCompute() throws Exception {
1629	>	CCF f = new LCCF(8);
1630		assertTrue(f.cancel(true));
1631		assertSame(f, f.fork());
1632		try {
#	Line 1550 | Line 1643 | public class CountedCompleterTest extend
1643		* quietlyJoin of a forked task returns when task cancelled
1644		*/
1645		public void testCancelledForkQuietlyJoinSingleton() {
1646	<	ForkJoinTask a =  new CheckedFJTask() {
1647	<	public void realCompute() {
1648	<	CCF f = new LCCF(null, 8);
1646	>	ForkJoinTask a = new CheckedRecursiveAction() {
1647	>	protected void realCompute() {
1648	>	CCF f = new LCCF(8);
1649		assertTrue(f.cancel(true));
1650		assertSame(f, f.fork());
1651		f.quietlyJoin();
#	Line 1565 | Line 1658 | public class CountedCompleterTest extend
1658		* invoke task throws exception after invoking completeExceptionally
1659		*/
1660		public void testCompleteExceptionallySingleton() {
1661	<	ForkJoinTask a =  new CheckedFJTask() {
1662	<	public void realCompute() {
1663	<	CCF f = new LCCF(null, 8);
1664	<	f.completeExceptionally(new FJException());
1665	<	try {
1666	<	f.invoke();
1667	<	shouldThrow();
1668	<	} catch (FJException success) {
1576	<	checkCompletedAbnormally(f, success);
1577	<	}
1661	>	ForkJoinTask a = new CheckedRecursiveAction() {
1662	>	protected void realCompute() {
1663	>	CCF n = new LCCF(8);
1664	>	CCF f = new LCCF(n, 8);
1665	>	FJException ex = new FJException();
1666	>	f.completeExceptionally(ex);
1667	>	f.checkCompletedExceptionally(ex);
1668	>	n.checkCompletedExceptionally(ex);
1669		}};
1670		testInvokeOnPool(singletonPool(), a);
1671		}
#	Line 1583 | Line 1674 | public class CountedCompleterTest extend
1674		* invokeAll(t1, t2) invokes all task arguments
1675		*/
1676		public void testInvokeAll2Singleton() {
1677	<	ForkJoinTask a =  new CheckedFJTask() {
1678	<	public void realCompute() {
1679	<	CCF f = new LCCF(null, 8);
1680	<	CCF g = new LCCF(null, 9);
1677	>	ForkJoinTask a = new CheckedRecursiveAction() {
1678	>	protected void realCompute() {
1679	>	CCF f = new LCCF(8);
1680	>	CCF g = new LCCF(9);
1681		invokeAll(f, g);
1682		assertEquals(21, f.number);
1683		assertEquals(34, g.number);
#	Line 1600 | Line 1691 | public class CountedCompleterTest extend
1691		* invokeAll(tasks) with 1 argument invokes task
1692		*/
1693		public void testInvokeAll1Singleton() {
1694	<	ForkJoinTask a =  new CheckedFJTask() {
1695	<	public void realCompute() {
1696	<	CCF f = new LCCF(null, 8);
1694	>	ForkJoinTask a = new CheckedRecursiveAction() {
1695	>	protected void realCompute() {
1696	>	CCF f = new LCCF(8);
1697		invokeAll(f);
1698		checkCompletedNormally(f);
1699		assertEquals(21, f.number);
#	Line 1614 | Line 1705 | public class CountedCompleterTest extend
1705		* invokeAll(tasks) with > 2 argument invokes tasks
1706		*/
1707		public void testInvokeAll3Singleton() {
1708	<	ForkJoinTask a =  new CheckedFJTask() {
1709	<	public void realCompute() {
1710	<	CCF f = new LCCF(null, 8);
1711	<	CCF g = new LCCF(null, 9);
1712	<	CCF h = new LCCF(null, 7);
1708	>	ForkJoinTask a = new CheckedRecursiveAction() {
1709	>	protected void realCompute() {
1710	>	CCF f = new LCCF(8);
1711	>	CCF g = new LCCF(9);
1712	>	CCF h = new LCCF(7);
1713		invokeAll(f, g, h);
1714		assertEquals(21, f.number);
1715		assertEquals(34, g.number);
#	Line 1634 | Line 1725 | public class CountedCompleterTest extend
1725		* invokeAll(collection) invokes all tasks in the collection
1726		*/
1727		public void testInvokeAllCollectionSingleton() {
1728	<	ForkJoinTask a =  new CheckedFJTask() {
1729	<	public void realCompute() {
1730	<	CCF f = new LCCF(null, 8);
1731	<	CCF g = new LCCF(null, 9);
1732	<	CCF h = new LCCF(null, 7);
1728	>	ForkJoinTask a = new CheckedRecursiveAction() {
1729	>	protected void realCompute() {
1730	>	CCF f = new LCCF(8);
1731	>	CCF g = new LCCF(9);
1732	>	CCF h = new LCCF(7);
1733		HashSet set = new HashSet();
1734		set.add(f);
1735		set.add(g);
#	Line 1658 | Line 1749 | public class CountedCompleterTest extend
1749		* invokeAll(tasks) with any null task throws NPE
1750		*/
1751		public void testInvokeAllNPESingleton() {
1752	<	ForkJoinTask a =  new CheckedFJTask() {
1753	<	public void realCompute() {
1754	<	CCF f = new LCCF(null, 8);
1755	<	CCF g = new LCCF(null, 9);
1752	>	ForkJoinTask a = new CheckedRecursiveAction() {
1753	>	protected void realCompute() {
1754	>	CCF f = new LCCF(8);
1755	>	CCF g = new LCCF(9);
1756		CCF h = null;
1757		try {
1758		invokeAll(f, g, h);
#	Line 1675 | Line 1766 | public class CountedCompleterTest extend
1766		* invokeAll(t1, t2) throw exception if any task does
1767		*/
1768		public void testAbnormalInvokeAll2Singleton() {
1769	<	ForkJoinTask a =  new CheckedFJTask() {
1770	<	public void realCompute() {
1771	<	CCF f = new LCCF(null, 8);
1772	<	FailingCCF g = new LFCCF(null, 9);
1769	>	ForkJoinTask a = new CheckedRecursiveAction() {
1770	>	protected void realCompute() {
1771	>	CCF f = new LCCF(8);
1772	>	FailingCCF g = new LFCCF(9);
1773		try {
1774		invokeAll(f, g);
1775		shouldThrow();
#	Line 1693 | Line 1784 | public class CountedCompleterTest extend
1784		* invokeAll(tasks) with 1 argument throws exception if task does
1785		*/
1786		public void testAbnormalInvokeAll1Singleton() {
1787	<	ForkJoinTask a =  new CheckedFJTask() {
1788	<	public void realCompute() {
1789	<	FailingCCF g = new LFCCF(null, 9);
1787	>	ForkJoinTask a = new CheckedRecursiveAction() {
1788	>	protected void realCompute() {
1789	>	FailingCCF g = new LFCCF(9);
1790		try {
1791		invokeAll(g);
1792		shouldThrow();
#	Line 1710 | Line 1801 | public class CountedCompleterTest extend
1801		* invokeAll(tasks) with > 2 argument throws exception if any task does
1802		*/
1803		public void testAbnormalInvokeAll3Singleton() {
1804	<	ForkJoinTask a =  new CheckedFJTask() {
1805	<	public void realCompute() {
1806	<	CCF f = new LCCF(null, 8);
1807	<	FailingCCF g = new LFCCF(null, 9);
1808	<	CCF h = new LCCF(null, 7);
1804	>	ForkJoinTask a = new CheckedRecursiveAction() {
1805	>	protected void realCompute() {
1806	>	CCF f = new LCCF(8);
1807	>	FailingCCF g = new LFCCF(9);
1808	>	CCF h = new LCCF(7);
1809		try {
1810		invokeAll(f, g, h);
1811		shouldThrow();
#	Line 1726 | Line 1817 | public class CountedCompleterTest extend
1817		}
1818
1819		/**
1820	<	* invokeAll(collection)  throws exception if any task does
1820	>	* invokeAll(collection) throws exception if any task does
1821		*/
1822		public void testAbnormalInvokeAllCollectionSingleton() {
1823	<	ForkJoinTask a =  new CheckedFJTask() {
1824	<	public void realCompute() {
1825	<	FailingCCF f = new LFCCF(null, 8);
1826	<	CCF g = new LCCF(null, 9);
1827	<	CCF h = new LCCF(null, 7);
1823	>	ForkJoinTask a = new CheckedRecursiveAction() {
1824	>	protected void realCompute() {
1825	>	FailingCCF f = new LFCCF(8);
1826	>	CCF g = new LCCF(9);
1827	>	CCF h = new LCCF(7);
1828		HashSet set = new HashSet();
1829		set.add(f);
1830		set.add(g);

Diff Legend

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