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) { |
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 = |
23 |
< |
new ForkJoinPool(1, ForkJoinPool.defaultForkJoinWorkerThreadFactory, |
24 |
< |
null, 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 { |
43 |
|
FJException() { super(); } |
80 |
|
* isCompletedAbnormally and isCancelled return false for normally |
81 |
|
* completed tasks. getRawResult of a completed non-null task |
82 |
|
* returns value; |
67 |
– |
* |
83 |
|
*/ |
84 |
|
public void testInvoke() { |
85 |
|
RecursiveTask<Integer> a = new RecursiveTask<Integer>() { |
94 |
|
return r; |
95 |
|
} |
96 |
|
}; |
97 |
< |
assertTrue(mainPool.invoke(a) == 21); |
97 |
> |
assertEquals(21, (int) testInvokeOnPool(mainPool(), a)); |
98 |
|
} |
99 |
|
|
100 |
|
/** |
115 |
|
return r; |
116 |
|
} |
117 |
|
}; |
118 |
< |
assertTrue(mainPool.invoke(a) == 21); |
118 |
> |
assertEquals(21, (int) testInvokeOnPool(mainPool(), a)); |
119 |
|
} |
120 |
|
|
121 |
|
/** |
132 |
|
return r; |
133 |
|
} |
134 |
|
}; |
135 |
< |
assertTrue(mainPool.invoke(a) == 21); |
135 |
> |
assertEquals(21, (int) testInvokeOnPool(mainPool(), a)); |
136 |
|
} |
137 |
|
|
138 |
|
/** |
154 |
|
return NoResult; |
155 |
|
} |
156 |
|
}; |
157 |
< |
assertTrue(mainPool.invoke(a) == 21); |
157 |
> |
assertEquals(21, (int) testInvokeOnPool(mainPool(), a)); |
158 |
|
} |
159 |
|
|
160 |
|
/** |
176 |
|
return NoResult; |
177 |
|
} |
178 |
|
}; |
179 |
< |
assertTrue(mainPool.invoke(a) == 21); |
179 |
> |
assertEquals(21, (int) testInvokeOnPool(mainPool(), a)); |
180 |
|
} |
181 |
|
|
182 |
|
/** |
194 |
|
return r; |
195 |
|
} |
196 |
|
}; |
197 |
< |
assertTrue(mainPool.invoke(a) == 21); |
197 |
> |
assertEquals(21, (int) testInvokeOnPool(mainPool(), a)); |
198 |
|
} |
199 |
|
|
200 |
|
|
215 |
|
return r; |
216 |
|
} |
217 |
|
}; |
218 |
< |
assertTrue(mainPool.invoke(a) == 21); |
218 |
> |
assertEquals(21, (int) testInvokeOnPool(mainPool(), a)); |
219 |
|
} |
220 |
|
|
221 |
|
|
235 |
|
return NoResult; |
236 |
|
} |
237 |
|
}; |
238 |
< |
mainPool.invoke(a); |
238 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
239 |
|
} |
240 |
|
|
241 |
|
/** |
250 |
|
return NoResult; |
251 |
|
} |
252 |
|
}; |
253 |
< |
mainPool.invoke(a); |
253 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
254 |
|
} |
255 |
|
|
256 |
|
/** |
270 |
|
return NoResult; |
271 |
|
} |
272 |
|
}; |
273 |
< |
mainPool.invoke(a); |
273 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
274 |
|
} |
275 |
|
|
276 |
|
/** |
292 |
|
return NoResult; |
293 |
|
} |
294 |
|
}; |
295 |
< |
mainPool.invoke(a); |
295 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
296 |
|
} |
297 |
|
|
298 |
|
/** |
314 |
|
return NoResult; |
315 |
|
} |
316 |
|
}; |
317 |
< |
mainPool.invoke(a); |
317 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
318 |
|
} |
319 |
|
|
320 |
|
/** |
332 |
|
return NoResult; |
333 |
|
} |
334 |
|
}; |
335 |
< |
mainPool.invoke(a); |
335 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
336 |
|
} |
337 |
|
|
338 |
|
/** |
352 |
|
return NoResult; |
353 |
|
} |
354 |
|
}; |
355 |
< |
mainPool.invoke(a); |
355 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
356 |
|
} |
357 |
|
|
358 |
|
/** |
373 |
|
return NoResult; |
374 |
|
} |
375 |
|
}; |
376 |
< |
mainPool.invoke(a); |
376 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
377 |
|
} |
378 |
|
|
379 |
|
/** |
396 |
|
return NoResult; |
397 |
|
} |
398 |
|
}; |
399 |
< |
mainPool.invoke(a); |
399 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
400 |
|
} |
401 |
|
|
402 |
|
/** |
419 |
|
return NoResult; |
420 |
|
} |
421 |
|
}; |
422 |
< |
mainPool.invoke(a); |
422 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
423 |
|
} |
424 |
|
|
425 |
|
/** |
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 |
|
/** |
478 |
|
return NoResult; |
479 |
|
} |
480 |
|
}; |
481 |
< |
mainPool.invoke(a); |
481 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
482 |
|
} |
483 |
|
|
484 |
|
/** |
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>() { |
504 |
|
return NoResult; |
505 |
|
} |
506 |
|
}; |
507 |
< |
assertEquals(a.invoke(), NoResult); |
507 |
> |
assertSame(NoResult, a.invoke()); |
508 |
|
} |
509 |
|
|
510 |
|
/** |
525 |
|
return NoResult; |
526 |
|
} |
527 |
|
}; |
528 |
< |
mainPool.invoke(a); |
528 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
529 |
|
} |
530 |
|
|
531 |
|
/** |
545 |
|
return NoResult; |
546 |
|
} |
547 |
|
}; |
548 |
< |
mainPool.invoke(a); |
548 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
549 |
|
} |
550 |
|
|
551 |
|
/** |
562 |
|
return r; |
563 |
|
} |
564 |
|
}; |
565 |
< |
mainPool.invoke(a); |
565 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
566 |
|
} |
567 |
|
|
568 |
|
/** |
581 |
|
return NoResult; |
582 |
|
} |
583 |
|
}; |
584 |
< |
mainPool.invoke(a); |
584 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
585 |
|
} |
586 |
|
|
587 |
|
/** |
597 |
|
return NoResult; |
598 |
|
} |
599 |
|
}; |
600 |
< |
mainPool.invoke(a); |
600 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
601 |
|
} |
602 |
|
|
603 |
|
/** |
619 |
|
return NoResult; |
620 |
|
} |
621 |
|
}; |
622 |
< |
mainPool.invoke(a); |
622 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
623 |
|
} |
624 |
|
|
625 |
|
/** |
645 |
|
return NoResult; |
646 |
|
} |
647 |
|
}; |
648 |
< |
mainPool.invoke(a); |
648 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
649 |
|
} |
650 |
|
|
651 |
|
|
666 |
|
return NoResult; |
667 |
|
} |
668 |
|
}; |
669 |
< |
mainPool.invoke(a); |
669 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
670 |
|
} |
671 |
|
|
672 |
|
/** |
685 |
|
return NoResult; |
686 |
|
} |
687 |
|
}; |
688 |
< |
mainPool.invoke(a); |
688 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
689 |
|
} |
690 |
|
|
691 |
|
/** |
706 |
|
return NoResult; |
707 |
|
} |
708 |
|
}; |
709 |
< |
mainPool.invoke(a); |
709 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
710 |
|
} |
711 |
|
|
712 |
|
/** |
731 |
|
return NoResult; |
732 |
|
} |
733 |
|
}; |
734 |
< |
mainPool.invoke(a); |
734 |
> |
assertSame(NoResult, testInvokeOnPool(mainPool(), a)); |
735 |
|
} |
736 |
|
|
737 |
|
/** |
752 |
|
return NoResult; |
753 |
|
} |
754 |
|
}; |
755 |
< |
singletonPool.invoke(a); |
755 |
> |
assertSame(NoResult, testInvokeOnPool(singletonPool(), a)); |
756 |
|
} |
757 |
|
|
758 |
|
/** |
773 |
|
return NoResult; |
774 |
|
} |
775 |
|
}; |
776 |
< |
singletonPool.invoke(a); |
776 |
> |
assertSame(NoResult, testInvokeOnPool(singletonPool(), a)); |
777 |
|
} |
778 |
|
|
779 |
|
/** |
793 |
|
return NoResult; |
794 |
|
} |
795 |
|
}; |
796 |
< |
singletonPool.invoke(a); |
796 |
> |
assertSame(NoResult, testInvokeOnPool(singletonPool(), a)); |
797 |
|
} |
798 |
|
|
799 |
|
/** |
813 |
|
return NoResult; |
814 |
|
} |
815 |
|
}; |
816 |
< |
singletonPool.invoke(a); |
816 |
> |
assertSame(NoResult, testInvokeOnPool(singletonPool(), a)); |
817 |
|
} |
818 |
|
|
819 |
|
/** |
820 |
< |
* pollTask returns an unexecuted task |
805 |
< |
* without executing it |
820 |
> |
* pollTask returns an unexecuted task without executing it |
821 |
|
*/ |
822 |
|
public void testPollTask() { |
823 |
|
RecursiveTask<Integer> a = new RecursiveTask<Integer>() { |
833 |
|
return NoResult; |
834 |
|
} |
835 |
|
}; |
836 |
< |
singletonPool.invoke(a); |
836 |
> |
assertSame(NoResult, testInvokeOnPool(singletonPool(), a)); |
837 |
|
} |
838 |
|
|
839 |
|
/** |
853 |
|
return NoResult; |
854 |
|
} |
855 |
|
}; |
856 |
< |
asyncSingletonPool.invoke(a); |
856 |
> |
assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a)); |
857 |
|
} |
858 |
|
|
859 |
|
/** |
874 |
|
return NoResult; |
875 |
|
} |
876 |
|
}; |
877 |
< |
asyncSingletonPool.invoke(a); |
877 |
> |
assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a)); |
878 |
|
} |
879 |
|
|
880 |
|
/** |
895 |
|
return NoResult; |
896 |
|
} |
897 |
|
}; |
898 |
< |
asyncSingletonPool.invoke(a); |
898 |
> |
assertSame(NoResult, testInvokeOnPool(asyncSingletonPool(), a)); |
899 |
|
} |
900 |
|
|
901 |
|
} |