1 |
|
/* |
2 |
|
* Written by Doug Lea with assistance from members of JCP JSR-166 |
3 |
|
* Expert Group and released to the public domain, as explained at |
4 |
< |
* http://creativecommons.org/licenses/publicdomain |
4 |
> |
* http://creativecommons.org/publicdomain/zero/1.0/ |
5 |
|
*/ |
6 |
|
|
7 |
|
import junit.framework.*; |
134 |
|
assertFalse(a.isCancelled()); |
135 |
|
assertFalse(a.isCompletedNormally()); |
136 |
|
assertTrue(a.isCompletedAbnormally()); |
137 |
< |
assertSame(t, a.getException()); |
137 |
> |
assertSame(t.getClass(), a.getException().getClass()); |
138 |
|
assertNull(a.getRawResult()); |
139 |
|
assertFalse(a.cancel(false)); |
140 |
|
assertFalse(a.cancel(true)); |
143 |
|
a.join(); |
144 |
|
shouldThrow(); |
145 |
|
} catch (Throwable expected) { |
146 |
< |
assertSame(t, expected); |
146 |
> |
assertSame(expected.getClass(), t.getClass()); |
147 |
|
} |
148 |
|
|
149 |
|
try { |
150 |
|
a.get(); |
151 |
|
shouldThrow(); |
152 |
|
} catch (ExecutionException success) { |
153 |
< |
assertSame(t, success.getCause()); |
153 |
> |
assertSame(t.getClass(), success.getCause().getClass()); |
154 |
|
} catch (Throwable fail) { threadUnexpectedException(fail); } |
155 |
|
|
156 |
|
try { |
157 |
|
a.get(5L, SECONDS); |
158 |
|
shouldThrow(); |
159 |
|
} catch (ExecutionException success) { |
160 |
< |
assertSame(t, success.getCause()); |
160 |
> |
assertSame(t.getClass(), success.getCause().getClass()); |
161 |
|
} catch (Throwable fail) { threadUnexpectedException(fail); } |
162 |
|
} |
163 |
|
|
164 |
< |
static final class FJException extends RuntimeException { |
165 |
< |
FJException() { super(); } |
164 |
> |
public static final class FJException extends RuntimeException { |
165 |
> |
public FJException() { super(); } |
166 |
> |
public FJException(Throwable cause) { super(cause); } |
167 |
|
} |
168 |
|
|
169 |
|
// A simple recursive action for testing |
256 |
|
RecursiveAction a = new CheckedRecursiveAction() { |
257 |
|
public void realCompute() { |
258 |
|
FibAction f = new FibAction(8); |
259 |
+ |
final Thread myself = Thread.currentThread(); |
260 |
|
|
261 |
|
// test join() |
262 |
|
assertSame(f, f.fork()); |
263 |
< |
Thread.currentThread().interrupt(); |
263 |
> |
myself.interrupt(); |
264 |
> |
assertTrue(myself.isInterrupted()); |
265 |
|
assertNull(f.join()); |
266 |
|
Thread.interrupted(); |
267 |
|
assertEquals(21, f.result); |
270 |
|
f.reinitialize(); |
271 |
|
f.cancel(true); |
272 |
|
assertSame(f, f.fork()); |
273 |
< |
Thread.currentThread().interrupt(); |
273 |
> |
myself.interrupt(); |
274 |
> |
assertTrue(myself.isInterrupted()); |
275 |
|
try { |
276 |
|
f.join(); |
277 |
|
shouldThrow(); |
283 |
|
f.reinitialize(); |
284 |
|
f.completeExceptionally(new FJException()); |
285 |
|
assertSame(f, f.fork()); |
286 |
< |
Thread.currentThread().interrupt(); |
286 |
> |
myself.interrupt(); |
287 |
> |
assertTrue(myself.isInterrupted()); |
288 |
|
try { |
289 |
|
f.join(); |
290 |
|
shouldThrow(); |
296 |
|
// test quietlyJoin() |
297 |
|
f.reinitialize(); |
298 |
|
assertSame(f, f.fork()); |
299 |
< |
Thread.currentThread().interrupt(); |
299 |
> |
myself.interrupt(); |
300 |
> |
assertTrue(myself.isInterrupted()); |
301 |
|
f.quietlyJoin(); |
302 |
|
Thread.interrupted(); |
303 |
|
assertEquals(21, f.result); |
306 |
|
f.reinitialize(); |
307 |
|
f.cancel(true); |
308 |
|
assertSame(f, f.fork()); |
309 |
< |
Thread.currentThread().interrupt(); |
309 |
> |
myself.interrupt(); |
310 |
> |
assertTrue(myself.isInterrupted()); |
311 |
|
f.quietlyJoin(); |
312 |
|
Thread.interrupted(); |
313 |
|
checkCancelled(f); |
315 |
|
f.reinitialize(); |
316 |
|
f.completeExceptionally(new FJException()); |
317 |
|
assertSame(f, f.fork()); |
318 |
< |
Thread.currentThread().interrupt(); |
318 |
> |
myself.interrupt(); |
319 |
> |
assertTrue(myself.isInterrupted()); |
320 |
|
f.quietlyJoin(); |
321 |
|
Thread.interrupted(); |
322 |
|
checkCompletedAbnormally(f, f.getException()); |
356 |
|
public void realRun() throws InterruptedException { |
357 |
|
FibAction[] fibActions = sq.take(); |
358 |
|
FibAction f; |
359 |
+ |
final Thread myself = Thread.currentThread(); |
360 |
|
|
361 |
|
// test join() ------------ |
362 |
|
|
363 |
|
f = fibActions[0]; |
364 |
|
assertFalse(ForkJoinTask.inForkJoinPool()); |
365 |
< |
Thread.currentThread().interrupt(); |
365 |
> |
myself.interrupt(); |
366 |
> |
assertTrue(myself.isInterrupted()); |
367 |
|
assertNull(f.join()); |
368 |
|
assertTrue(Thread.interrupted()); |
369 |
|
assertEquals(21, f.result); |
370 |
|
checkCompletedNormally(f); |
371 |
|
|
372 |
|
f = fibActions[1]; |
373 |
< |
Thread.currentThread().interrupt(); |
373 |
> |
myself.interrupt(); |
374 |
> |
assertTrue(myself.isInterrupted()); |
375 |
|
try { |
376 |
|
f.join(); |
377 |
|
shouldThrow(); |
381 |
|
} |
382 |
|
|
383 |
|
f = fibActions[2]; |
384 |
< |
Thread.currentThread().interrupt(); |
384 |
> |
myself.interrupt(); |
385 |
> |
assertTrue(myself.isInterrupted()); |
386 |
|
try { |
387 |
|
f.join(); |
388 |
|
shouldThrow(); |
394 |
|
// test quietlyJoin() --------- |
395 |
|
|
396 |
|
f = fibActions[3]; |
397 |
< |
Thread.currentThread().interrupt(); |
397 |
> |
myself.interrupt(); |
398 |
> |
assertTrue(myself.isInterrupted()); |
399 |
|
f.quietlyJoin(); |
400 |
|
assertTrue(Thread.interrupted()); |
401 |
|
assertEquals(21, f.result); |
402 |
|
checkCompletedNormally(f); |
403 |
|
|
404 |
|
f = fibActions[4]; |
405 |
< |
Thread.currentThread().interrupt(); |
405 |
> |
myself.interrupt(); |
406 |
> |
assertTrue(myself.isInterrupted()); |
407 |
|
f.quietlyJoin(); |
408 |
|
assertTrue(Thread.interrupted()); |
409 |
|
checkCancelled(f); |
410 |
|
|
411 |
|
f = fibActions[5]; |
412 |
< |
Thread.currentThread().interrupt(); |
412 |
> |
myself.interrupt(); |
413 |
> |
assertTrue(myself.isInterrupted()); |
414 |
|
f.quietlyJoin(); |
415 |
|
assertTrue(Thread.interrupted()); |
416 |
|
assertTrue(f.getException() instanceof FJException); |
770 |
|
RecursiveAction a = new CheckedRecursiveAction() { |
771 |
|
public void realCompute() { |
772 |
|
ForkJoinWorkerThread w = |
773 |
< |
(ForkJoinWorkerThread)(Thread.currentThread()); |
773 |
> |
(ForkJoinWorkerThread) Thread.currentThread(); |
774 |
|
assertTrue(w.getPoolIndex() >= 0); |
775 |
< |
assertTrue(w.getPoolIndex() < mainPool.getPoolSize()); |
775 |
> |
// pool size can shrink after assigning index, so cannot check |
776 |
> |
// assertTrue(w.getPoolIndex() < mainPool.getPoolSize()); |
777 |
|
}}; |
778 |
|
testInvokeOnPool(mainPool, a); |
779 |
|
} |