ViewVC Help

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

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

Comparing jsr166/src/test/tck/RecursiveTaskTest.java (file contents):
Revision 1.8 by jsr166, Sat Nov 21 02:07:27 2009 UTC vs.
Revision 1.14 by dl, Mon Sep 13 10:49:59 2010 UTC

#	Line 3 | Line 3
3		* Expert Group and released to the public domain, as explained at
4		* http://creativecommons.org/licenses/publicdomain
5		*/
6	+
7		import junit.framework.*;
8		import java.util.concurrent.*;
9		import java.util.*;
10
10	–
11		public class RecursiveTaskTest 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(RecursiveTaskTest.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);
20	>	private static ForkJoinPool mainPool() {
21	>	return new ForkJoinPool();
22	>	}
23	>
24	>	private static ForkJoinPool singletonPool() {
25	>	return new ForkJoinPool(1);
26	>	}
27	>
28	>	private static ForkJoinPool asyncSingletonPool() {
29	>	return new ForkJoinPool(1,
30	>	ForkJoinPool.defaultForkJoinWorkerThreadFactory,
31	>	null, true);
32	>	}
33	>
34	>	private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
35	>	try {
36	>	return pool.invoke(a);
37	>	} finally {
38	>	joinPool(pool);
39	>	}
40		}
41
42		static final class FJException extends RuntimeException {
#	Line 65 | Line 80 | public class RecursiveTaskTest extends J
80		* isCompletedAbnormally and isCancelled return false for normally
81		* completed tasks. getRawResult of a completed non-null task
82		* returns value;
68	–	*
83		*/
84		public void testInvoke() {
85		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
#	Line 80 | Line 94 | public class RecursiveTaskTest extends J
94		return r;
95		}
96		};
97	<	assertTrue(mainPool.invoke(a) == 21);
97	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
98		}
99
100		/**
#	Line 101 | Line 115 | public class RecursiveTaskTest extends J
115		return r;
116		}
117		};
118	<	assertTrue(mainPool.invoke(a) == 21);
118	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
119		}
120
121		/**
#	Line 118 | Line 132 | public class RecursiveTaskTest extends J
132		return r;
133		}
134		};
135	<	assertTrue(mainPool.invoke(a) == 21);
135	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
136		}
137
138		/**
#	Line 140 | Line 154 | public class RecursiveTaskTest extends J
154		return NoResult;
155		}
156		};
157	<	assertTrue(mainPool.invoke(a) == 21);
157	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
158		}
159
160		/**
#	Line 162 | Line 176 | public class RecursiveTaskTest extends J
176		return NoResult;
177		}
178		};
179	<	assertTrue(mainPool.invoke(a) == 21);
166	<	}
167	<
168	<	/**
169	<	* helpJoin of a forked task returns when task completes
170	<	*/
171	<	public void testForkHelpJoin() {
172	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
173	<	public Integer compute() {
174	<	FibTask f = new FibTask(8);
175	<	f.fork();
176	<	Integer r = f.helpJoin();
177	<	threadAssertTrue(r == 21);
178	<	threadAssertTrue(f.isDone());
179	<	return r;
180	<	}
181	<	};
182	<	assertTrue(mainPool.invoke(a) == 21);
179	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
180		}
181
182		/**
#	Line 197 | Line 194 | public class RecursiveTaskTest extends J
194		return r;
195		}
196		};
197	<	assertTrue(mainPool.invoke(a) == 21);
201	<	}
202	<
203	<
204	<	/**
205	<	* quietlyHelpJoin of a forked task returns when task completes
206	<	*/
207	<	public void testForkQuietlyHelpJoin() {
208	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
209	<	public Integer compute() {
210	<	FibTask f = new FibTask(8);
211	<	f.fork();
212	<	f.quietlyHelpJoin();
213	<	Integer r = f.getRawResult();
214	<	threadAssertTrue(r == 21);
215	<	threadAssertTrue(f.isDone());
216	<	return r;
217	<	}
218	<	};
219	<	assertTrue(mainPool.invoke(a) == 21);
197	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
198		}
199
200
#	Line 237 | Line 215 | public class RecursiveTaskTest extends J
215		return r;
216		}
217		};
218	<	assertTrue(mainPool.invoke(a) == 21);
218	>	assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
219		}
220
221
#	Line 257 | Line 235 | public class RecursiveTaskTest extends J
235		return NoResult;
236		}
237		};
238	<	mainPool.invoke(a);
238	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
239		}
240
241		/**
#	Line 272 | Line 250 | public class RecursiveTaskTest extends J
250		return NoResult;
251		}
252		};
253	<	mainPool.invoke(a);
253	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
254		}
255
256		/**
#	Line 292 | Line 270 | public class RecursiveTaskTest extends J
270		return NoResult;
271		}
272		};
273	<	mainPool.invoke(a);
273	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
274		}
275
276		/**
#	Line 314 | Line 292 | public class RecursiveTaskTest extends J
292		return NoResult;
293		}
294		};
295	<	mainPool.invoke(a);
295	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
296		}
297
298		/**
#	Line 336 | Line 314 | public class RecursiveTaskTest extends J
314		return NoResult;
315		}
316		};
317	<	mainPool.invoke(a);
340	<	}
341	<
342	<	/**
343	<	* join of a forked task throws exception when task completes abnormally
344	<	*/
345	<	public void testAbnormalForkHelpJoin() {
346	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
347	<	public Integer compute() {
348	<	try {
349	<	FailingFibTask f = new FailingFibTask(8);
350	<	f.fork();
351	<	Integer r = f.helpJoin();
352	<	shouldThrow();
353	<	return r;
354	<	} catch (FJException success) {
355	<	}
356	<	return NoResult;
357	<	}
358	<	};
359	<	mainPool.invoke(a);
360	<	}
361	<
362	<	/**
363	<	* quietlyHelpJoin of a forked task returns when task completes abnormally.
364	<	* getException of failed task returns its exception.
365	<	* isCompletedAbnormally of a failed task returns true.
366	<	* isCancelled of a failed uncancelled task returns false
367	<	*/
368	<	public void testAbnormalForkQuietlyHelpJoin() {
369	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
370	<	public Integer compute() {
371	<	FailingFibTask f = new FailingFibTask(8);
372	<	f.fork();
373	<	f.quietlyHelpJoin();
374	<	threadAssertTrue(f.isDone());
375	<	threadAssertTrue(f.isCompletedAbnormally());
376	<	threadAssertFalse(f.isCancelled());
377	<	threadAssertTrue(f.getException() instanceof FJException);
378	<	return NoResult;
379	<	}
380	<	};
381	<	mainPool.invoke(a);
317	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
318		}
319
320		/**
#	Line 396 | Line 332 | public class RecursiveTaskTest extends J
332		return NoResult;
333		}
334		};
335	<	mainPool.invoke(a);
335	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
336		}
337
338		/**
#	Line 416 | Line 352 | public class RecursiveTaskTest extends J
352		return NoResult;
353		}
354		};
355	<	mainPool.invoke(a);
355	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
356		}
357
358		/**
#	Line 437 | Line 373 | public class RecursiveTaskTest extends J
373		return NoResult;
374		}
375		};
376	<	mainPool.invoke(a);
376	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
377		}
378
379		/**
#	Line 460 | Line 396 | public class RecursiveTaskTest extends J
396		return NoResult;
397		}
398		};
399	<	mainPool.invoke(a);
399	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
400		}
401
402		/**
#	Line 483 | Line 419 | public class RecursiveTaskTest extends J
419		return NoResult;
420		}
421		};
422	<	mainPool.invoke(a);
487	<	}
488	<
489	<	/**
490	<	* join of a forked task throws exception when task cancelled
491	<	*/
492	<	public void testCancelledForkHelpJoin() {
493	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
494	<	public Integer compute() {
495	<	try {
496	<	FibTask f = new FibTask(8);
497	<	f.cancel(true);
498	<	f.fork();
499	<	Integer r = f.helpJoin();
500	<	shouldThrow();
501	<	return r;
502	<	} catch (CancellationException success) {
503	<	}
504	<	return NoResult;
505	<	}
506	<	};
507	<	mainPool.invoke(a);
508	<	}
509	<
510	<	/**
511	<	* quietlyHelpJoin of a forked task returns when task cancelled.
512	<	* getException of cancelled task returns its exception
513	<	* isCompletedAbnormally of a cancelled task returns true.
514	<	* isCancelled of a cancelled task returns true
515	<	*/
516	<	public void testCancelledForkQuietlyHelpJoin() {
517	<	RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
518	<	public Integer compute() {
519	<	FibTask f = new FibTask(8);
520	<	f.cancel(true);
521	<	f.fork();
522	<	f.quietlyHelpJoin();
523	<	threadAssertTrue(f.isDone());
524	<	threadAssertTrue(f.isCompletedAbnormally());
525	<	threadAssertTrue(f.isCancelled());
526	<	threadAssertTrue(f.getException() instanceof CancellationException);
527	<	return NoResult;
528	<	}
529	<	};
530	<	mainPool.invoke(a);
422	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
423		}
424
425		/**
#	Line 546 | Line 438 | public class RecursiveTaskTest extends J
438		return NoResult;
439		}
440		};
441	<	mainPool.invoke(a);
441	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
442		}
443
444		/**
445		* getPool of executing task returns its pool
446		*/
447		public void testGetPool() {
448	+	final ForkJoinPool mainPool = mainPool();
449		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
450		public Integer compute() {
451		threadAssertTrue(getPool() == mainPool);
452		return NoResult;
453		}
454		};
455	<	mainPool.invoke(a);
455	>	assertSame(NoResult, testInvokeOnPool(mainPool, a));
456		}
457
458		/**
#	Line 585 | Line 478 | public class RecursiveTaskTest extends J
478		return NoResult;
479		}
480		};
481	<	mainPool.invoke(a);
481	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
482		}
483
484		/**
#	Line 602 | Line 495 | public class RecursiveTaskTest extends J
495		}
496
497		/**
498	<	* setRawResult(null) succeeds
498	>	* The value set by setRawResult is returned by invoke
499		*/
500		public void testSetRawResult() {
501		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
#	Line 611 | Line 504 | public class RecursiveTaskTest extends J
504		return NoResult;
505		}
506		};
507	<	assertEquals(a.invoke(), NoResult);
507	>	assertSame(NoResult, a.invoke());
508		}
509
510		/**
#	Line 632 | Line 525 | public class RecursiveTaskTest extends J
525		return NoResult;
526		}
527		};
528	<	mainPool.invoke(a);
528	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
529		}
530
531		/**
#	Line 652 | Line 545 | public class RecursiveTaskTest extends J
545		return NoResult;
546		}
547		};
548	<	mainPool.invoke(a);
548	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
549		}
550
551		/**
#	Line 669 | Line 562 | public class RecursiveTaskTest extends J
562		return r;
563		}
564		};
565	<	mainPool.invoke(a);
565	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
566		}
567
568		/**
#	Line 688 | Line 581 | public class RecursiveTaskTest extends J
581		return NoResult;
582		}
583		};
584	<	mainPool.invoke(a);
584	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
585		}
586
587		/**
#	Line 704 | Line 597 | public class RecursiveTaskTest extends J
597		return NoResult;
598		}
599		};
600	<	mainPool.invoke(a);
600	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
601		}
602
603		/**
#	Line 726 | Line 619 | public class RecursiveTaskTest extends J
619		return NoResult;
620		}
621		};
622	<	mainPool.invoke(a);
622	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
623		}
624
625		/**
#	Line 752 | Line 645 | public class RecursiveTaskTest extends J
645		return NoResult;
646		}
647		};
648	<	mainPool.invoke(a);
648	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
649		}
650
651
#	Line 773 | Line 666 | public class RecursiveTaskTest extends J
666		return NoResult;
667		}
668		};
669	<	mainPool.invoke(a);
669	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
670		}
671
672		/**
#	Line 792 | Line 685 | public class RecursiveTaskTest extends J
685		return NoResult;
686		}
687		};
688	<	mainPool.invoke(a);
688	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
689		}
690
691		/**
#	Line 813 | Line 706 | public class RecursiveTaskTest extends J
706		return NoResult;
707		}
708		};
709	<	mainPool.invoke(a);
709	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
710		}
711
712		/**
#	Line 838 | Line 731 | public class RecursiveTaskTest extends J
731		return NoResult;
732		}
733		};
734	<	mainPool.invoke(a);
734	>	assertSame(NoResult, testInvokeOnPool(mainPool(), a));
735		}
736
737		/**
#	Line 859 | Line 752 | public class RecursiveTaskTest extends J
752		return NoResult;
753		}
754		};
755	<	singletonPool.invoke(a);
755	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
756		}
757
758		/**
#	Line 880 | Line 773 | public class RecursiveTaskTest extends J
773		return NoResult;
774		}
775		};
776	<	singletonPool.invoke(a);
776	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
777		}
778
779		/**
#	Line 900 | Line 793 | public class RecursiveTaskTest extends J
793		return NoResult;
794		}
795		};
796	<	singletonPool.invoke(a);
796	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
797		}
798
799		/**
#	Line 920 | Line 813 | public class RecursiveTaskTest extends J
813		return NoResult;
814		}
815		};
816	<	singletonPool.invoke(a);
816	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
817		}
818
819		/**
820	<	* pollTask returns an unexecuted task
928	<	* without executing it
820	>	* pollTask returns an unexecuted task without executing it
821		*/
822		public void testPollTask() {
823		RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
#	Line 941 | Line 833 | public class RecursiveTaskTest extends J
833		return NoResult;
834		}
835		};
836	<	singletonPool.invoke(a);
836	>	assertSame(NoResult, testInvokeOnPool(singletonPool(), a));
837		}
838
839		/**
#	Line 961 | Line 853 | public class RecursiveTaskTest extends J
853		return NoResult;
854		}
855		};
856	<	asyncSingletonPool.invoke(a);
856	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
857		}
858
859		/**
#	Line 982 | Line 874 | public class RecursiveTaskTest extends J
874		return NoResult;
875		}
876		};
877	<	asyncSingletonPool.invoke(a);
877	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
878		}
879
880		/**
#	Line 1003 | Line 895 | public class RecursiveTaskTest extends J
895		return NoResult;
896		}
897		};
898	<	asyncSingletonPool.invoke(a);
898	>	assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a));
899		}
900
901		}

Diff Legend

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