ViewVC Help

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

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

Comparing jsr166/src/test/tck/RecursiveActionTest.java (file contents):
Revision 1.7 by jsr166, Wed Aug 5 01:17:30 2009 UTC vs.
Revision 1.11 by jsr166, Wed Aug 25 00:07:03 2010 UTC

#	Line 11 | Line 11 | import java.util.*;
11		public class RecursiveActionTest extends JSR166TestCase {
12
13		public static void main(String[] args) {
14	<	junit.textui.TestRunner.run (suite());
14	>	junit.textui.TestRunner.run(suite());
15		}
16		public static Test suite() {
17	<	return new TestSuite(RecursiveActionTest.class);
17	>	return new TestSuite(RecursiveActionTest.class);
18		}
19
20		static final ForkJoinPool mainPool = new ForkJoinPool();
21		static final ForkJoinPool singletonPool = new ForkJoinPool(1);
22	<	static final ForkJoinPool asyncSingletonPool = new ForkJoinPool(1);
23	<	static {
24	<	asyncSingletonPool.setAsyncMode(true);
25	<	}
22	>	static final ForkJoinPool asyncSingletonPool =
23	>	new ForkJoinPool(1, ForkJoinPool.defaultForkJoinWorkerThreadFactory,
24	>	null, true);
25
26		static final class FJException extends RuntimeException {
27		FJException() { super(); }
#	Line 162 | Line 161 | public class RecursiveActionTest extends
161		*/
162		public void testForkTimedGetNPE() {
163		RecursiveAction a = new RecursiveAction() {
165	–	public void compute() {
166	–	try {
167	–	FibAction f = new FibAction(8);
168	–	f.fork();
169	–	f.get(5L, null);
170	–	shouldThrow();
171	–	} catch (NullPointerException success) {
172	–	} catch (Exception ex) {
173	–	unexpectedException(ex);
174	–	}
175	–	}
176	–	};
177	–	mainPool.invoke(a);
178	–	}
179	–
180	–	/**
181	–	* helpJoin of a forked task returns when task completes
182	–	*/
183	–	public void testForkHelpJoin() {
184	–	RecursiveAction a = new RecursiveAction() {
164		public void compute() {
165	<	FibAction f = new FibAction(8);
166	<	f.fork();
167	<	f.helpJoin();
168	<	threadAssertTrue(f.result == 21);
169	<	threadAssertTrue(f.isDone());
165	>	try {
166	>	FibAction f = new FibAction(8);
167	>	f.fork();
168	>	f.get(5L, null);
169	>	shouldThrow();
170	>	} catch (NullPointerException success) {
171	>	} catch (Exception ex) {
172	>	unexpectedException(ex);
173	>	}
174		}};
175		mainPool.invoke(a);
176		}
#	Line 209 | Line 192 | public class RecursiveActionTest extends
192
193
194		/**
212	–	* quietlyHelpJoin of a forked task returns when task completes
213	–	*/
214	–	public void testForkQuietlyHelpJoin() {
215	–	RecursiveAction a = new RecursiveAction() {
216	–	public void compute() {
217	–	FibAction f = new FibAction(8);
218	–	f.fork();
219	–	f.quietlyHelpJoin();
220	–	threadAssertTrue(f.result == 21);
221	–	threadAssertTrue(f.isDone());
222	–	}};
223	–	mainPool.invoke(a);
224	–	}
225	–
226	–
227	–	/**
195		* helpQuiesce returns when tasks are complete.
196		* getQueuedTaskCount returns 0 when quiescent
197		*/
#	Line 327 | Line 294 | public class RecursiveActionTest extends
294		}
295
296		/**
330	–	* join of a forked task throws exception when task completes abnormally
331	–	*/
332	–	public void testAbnormalForkHelpJoin() {
333	–	RecursiveAction a = new RecursiveAction() {
334	–	public void compute() {
335	–	try {
336	–	FailingFibAction f = new FailingFibAction(8);
337	–	f.fork();
338	–	f.helpJoin();
339	–	shouldThrow();
340	–	} catch (FJException success) {
341	–	}
342	–	}};
343	–	mainPool.invoke(a);
344	–	}
345	–
346	–	/**
347	–	* quietlyHelpJoin of a forked task returns when task completes abnormally.
348	–	* getException of failed task returns its exception.
349	–	* isCompletedAbnormally of a failed task returns true.
350	–	* isCancelled of a failed uncancelled task returns false
351	–	*/
352	–	public void testAbnormalForkQuietlyHelpJoin() {
353	–	RecursiveAction a = new RecursiveAction() {
354	–	public void compute() {
355	–	FailingFibAction f = new FailingFibAction(8);
356	–	f.fork();
357	–	f.quietlyHelpJoin();
358	–	threadAssertTrue(f.isDone());
359	–	threadAssertTrue(f.isCompletedAbnormally());
360	–	threadAssertFalse(f.isCancelled());
361	–	threadAssertTrue(f.getException() instanceof FJException);
362	–	}};
363	–	mainPool.invoke(a);
364	–	}
365	–
366	–	/**
297		* quietlyJoin of a forked task returns when task completes abnormally
298		*/
299		public void testAbnormalForkQuietlyJoin() {
#	Line 453 | Line 383 | public class RecursiveActionTest extends
383		}};
384		mainPool.invoke(a);
385		}
456	–
457	–	/**
458	–	* join of a forked task throws exception when task cancelled
459	–	*/
460	–	public void testCancelledForkHelpJoin() {
461	–	RecursiveAction a = new RecursiveAction() {
462	–	public void compute() {
463	–	try {
464	–	FibAction f = new FibAction(8);
465	–	f.cancel(true);
466	–	f.fork();
467	–	f.helpJoin();
468	–	shouldThrow();
469	–	} catch (CancellationException success) {
470	–	}
471	–	}};
472	–	mainPool.invoke(a);
473	–	}
474	–
475	–	/**
476	–	* quietlyHelpJoin of a forked task returns when task cancelled.
477	–	* getException of cancelled task returns its exception.
478	–	* isCompletedAbnormally of a cancelled task returns true.
479	–	* isCancelled of a cancelled task returns true
480	–	*/
481	–	public void testCancelledForkQuietlyHelpJoin() {
482	–	RecursiveAction a = new RecursiveAction() {
483	–	public void compute() {
484	–	FibAction f = new FibAction(8);
485	–	f.cancel(true);
486	–	f.fork();
487	–	f.quietlyHelpJoin();
488	–	threadAssertTrue(f.isDone());
489	–	threadAssertTrue(f.isCompletedAbnormally());
490	–	threadAssertTrue(f.isCancelled());
491	–	threadAssertTrue(f.getException() instanceof CancellationException);
492	–	}};
493	–	mainPool.invoke(a);
494	–	}
386
387		/**
388		* quietlyJoin of a forked task returns when task cancelled

Diff Legend

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