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.24 by jsr166, Mon Nov 22 20:19:47 2010 UTC vs.
Revision 1.31 by jsr166, Fri May 27 19:13:51 2011 UTC

# Line 1 | Line 1
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.*;
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 247 | Line 250 | public class RecursiveActionTest extends
250      }
251  
252      /**
253 <     * join/quietlyJoin of a forked task ignores interrupts
253 >     * join/quietlyJoin of a forked task succeeds in the presence of interrupts
254       */
255      public void testJoinIgnoresInterrupts() {
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 <                assertTrue(Thread.interrupted());
266 >                Thread.interrupted();
267                  assertEquals(21, f.result);
268                  checkCompletedNormally(f);
269  
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();
278                  } catch (CancellationException success) {
279 <                    assertTrue(Thread.interrupted());
279 >                    Thread.interrupted();
280                      checkCancelled(f);
281                  }
282  
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();
291                  } catch (FJException success) {
292 <                    assertTrue(Thread.interrupted());
292 >                    Thread.interrupted();
293                      checkCompletedAbnormally(f, success);
294                  }
295  
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 <                assertTrue(Thread.interrupted());
302 >                Thread.interrupted();
303                  assertEquals(21, f.result);
304                  checkCompletedNormally(f);
305  
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 <                assertTrue(Thread.interrupted());
312 >                Thread.interrupted();
313                  checkCancelled(f);
314  
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());
323 >            }};
324 >        testInvokeOnPool(mainPool(), a);
325 >        a.reinitialize();
326 >        testInvokeOnPool(singletonPool(), a);
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      /**
# Line 377 | Line 490 | public class RecursiveActionTest extends
490          testInvokeOnPool(mainPool(), a);
491      }
492  
380 –
493      /**
494       * helpQuiesce returns when tasks are complete.
495       * getQueuedTaskCount returns 0 when quiescent
# Line 387 | Line 499 | public class RecursiveActionTest extends
499              public void realCompute() {
500                  FibAction f = new FibAction(8);
501                  assertSame(f, f.fork());
502 <                f.helpQuiesce();
502 >                helpQuiesce();
503                  assertEquals(21, f.result);
504                  assertEquals(0, getQueuedTaskCount());
505                  checkCompletedNormally(f);
# Line 395 | Line 507 | public class RecursiveActionTest extends
507          testInvokeOnPool(mainPool(), a);
508      }
509  
398 –
510      /**
511       * invoke task throws exception when task completes abnormally
512       */
# Line 657 | Line 768 | public class RecursiveActionTest extends
768          RecursiveAction a = new CheckedRecursiveAction() {
769              public void realCompute() {
770                  ForkJoinWorkerThread w =
771 <                    (ForkJoinWorkerThread)(Thread.currentThread());
771 >                    (ForkJoinWorkerThread) Thread.currentThread();
772                  assertTrue(w.getPoolIndex() >= 0);
773 <                assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
773 >                // pool size can shrink after assigning index, so cannot check
774 >                // assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
775              }};
776          testInvokeOnPool(mainPool, a);
777      }
778  
667 –
779      /**
780       * setRawResult(null) succeeds
781       */
# Line 811 | Line 922 | public class RecursiveActionTest extends
922          testInvokeOnPool(mainPool(), a);
923      }
924  
814 –
925      /**
926       * invokeAll(tasks) with any null task throws NPE
927       */

Diff Legend

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