ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/RecursiveActionTest.java
(Generate patch)

Comparing jsr166/src/test/tck/RecursiveActionTest.java (file contents):
Revision 1.25 by jsr166, Tue Nov 23 06:33:26 2010 UTC vs.
Revision 1.29 by dl, Tue Feb 22 01:18:59 2011 UTC

# Line 6 | Line 6
6  
7   import junit.framework.*;
8   import java.util.concurrent.CancellationException;
9 + import java.util.concurrent.SynchronousQueue;
10   import java.util.concurrent.ExecutionException;
11   import java.util.concurrent.ForkJoinPool;
12 + import java.util.concurrent.ForkJoinTask;
13   import java.util.concurrent.ForkJoinWorkerThread;
14   import java.util.concurrent.RecursiveAction;
15   import java.util.concurrent.TimeUnit;
# Line 59 | Line 61 | public class RecursiveActionTest extends
61          assertNull(a.getException());
62          assertNull(a.getRawResult());
63  
64 <        if (! (Thread.currentThread() instanceof ForkJoinWorkerThread)) {
64 >        if (! ForkJoinTask.inForkJoinPool()) {
65              Thread.currentThread().interrupt();
66              try {
67                  a.get();
# Line 132 | Line 134 | public class RecursiveActionTest extends
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));
# Line 141 | Line 143 | public class RecursiveActionTest extends
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
# Line 253 | Line 256 | public class RecursiveActionTest extends
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);
# Line 265 | Line 270 | public class RecursiveActionTest extends
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();
# Line 277 | Line 283 | public class RecursiveActionTest extends
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();
# Line 289 | Line 296 | public class RecursiveActionTest extends
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);
# Line 298 | Line 306 | public class RecursiveActionTest extends
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);
# Line 306 | Line 315 | public class RecursiveActionTest extends
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());
# Line 317 | Line 327 | public class RecursiveActionTest extends
327      }
328  
329      /**
330 +     * join/quietlyJoin of a forked task when not in ForkJoinPool
331 +     * succeeds in the presence of interrupts
332 +     */
333 +    public void testJoinIgnoresInterruptsOutsideForkJoinPool() {
334 +        final SynchronousQueue<FibAction[]> sq =
335 +            new SynchronousQueue<FibAction[]>();
336 +        RecursiveAction a = new CheckedRecursiveAction() {
337 +            public void realCompute() throws InterruptedException {
338 +                FibAction[] fibActions = new FibAction[6];
339 +                for (int i = 0; i < fibActions.length; i++)
340 +                    fibActions[i] = new FibAction(8);
341 +
342 +                fibActions[1].cancel(false);
343 +                fibActions[2].completeExceptionally(new FJException());
344 +                fibActions[4].cancel(true);
345 +                fibActions[5].completeExceptionally(new FJException());
346 +
347 +                for (int i = 0; i < fibActions.length; i++)
348 +                    fibActions[i].fork();
349 +
350 +                sq.put(fibActions);
351 +
352 +                helpQuiesce();
353 +            }};
354 +
355 +        Runnable r = new CheckedRunnable() {
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 +                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 +                myself.interrupt();
374 +                assertTrue(myself.isInterrupted());
375 +                try {
376 +                    f.join();
377 +                    shouldThrow();
378 +                } catch (CancellationException success) {
379 +                    assertTrue(Thread.interrupted());
380 +                    checkCancelled(f);
381 +                }
382 +
383 +                f = fibActions[2];
384 +                myself.interrupt();
385 +                assertTrue(myself.isInterrupted());
386 +                try {
387 +                    f.join();
388 +                    shouldThrow();
389 +                } catch (FJException success) {
390 +                    assertTrue(Thread.interrupted());
391 +                    checkCompletedAbnormally(f, success);
392 +                }
393 +
394 +                // test quietlyJoin() ---------
395 +
396 +                f = fibActions[3];
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 +                myself.interrupt();
406 +                assertTrue(myself.isInterrupted());
407 +                f.quietlyJoin();
408 +                assertTrue(Thread.interrupted());
409 +                checkCancelled(f);
410 +
411 +                f = fibActions[5];
412 +                myself.interrupt();
413 +                assertTrue(myself.isInterrupted());
414 +                f.quietlyJoin();
415 +                assertTrue(Thread.interrupted());
416 +                assertTrue(f.getException() instanceof FJException);
417 +                checkCompletedAbnormally(f, f.getException());
418 +            }};
419 +
420 +        Thread t;
421 +
422 +        t = newStartedThread(r);
423 +        testInvokeOnPool(mainPool(), a);
424 +        awaitTermination(t, LONG_DELAY_MS);
425 +
426 +        a.reinitialize();
427 +        t = newStartedThread(r);
428 +        testInvokeOnPool(singletonPool(), a);
429 +        awaitTermination(t, LONG_DELAY_MS);
430 +    }
431 +
432 +    /**
433       * get of a forked task returns when task completes
434       */
435      public void testForkGet() {
# Line 657 | Line 770 | public class RecursiveActionTest extends
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      }

Diff Legend

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