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.39 by jsr166, Mon Jun 3 17:55:49 2013 UTC vs.
Revision 1.49 by jsr166, Sat Mar 18 18:20:00 2017 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 < import junit.framework.*;
7 > import static java.util.concurrent.TimeUnit.SECONDS;
8 >
9 > import java.util.Arrays;
10 > import java.util.HashSet;
11   import java.util.concurrent.CancellationException;
9 import java.util.concurrent.SynchronousQueue;
12   import java.util.concurrent.ExecutionException;
13   import java.util.concurrent.ForkJoinPool;
14   import java.util.concurrent.ForkJoinTask;
15   import java.util.concurrent.ForkJoinWorkerThread;
16   import java.util.concurrent.RecursiveAction;
17 + import java.util.concurrent.SynchronousQueue;
18   import java.util.concurrent.ThreadLocalRandom;
16 import java.util.concurrent.TimeUnit;
19   import java.util.concurrent.TimeoutException;
20 < import static java.util.concurrent.TimeUnit.SECONDS;
21 < import java.util.Arrays;
22 < import java.util.HashSet;
20 >
21 > import junit.framework.Test;
22 > import junit.framework.TestSuite;
23  
24   public class RecursiveActionTest extends JSR166TestCase {
25  
26      public static void main(String[] args) {
27 <        junit.textui.TestRunner.run(suite());
27 >        main(suite(), args);
28      }
29  
30      public static Test suite() {
# Line 44 | Line 46 | public class RecursiveActionTest extends
46      }
47  
48      private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
49 <        try {
49 >        try (PoolCleaner cleaner = cleaner(pool)) {
50              checkNotDone(a);
51  
52              assertNull(pool.invoke(a));
53  
54              checkCompletedNormally(a);
53        } finally {
54            joinPool(pool);
55          }
56      }
57  
# Line 168 | Line 168 | public class RecursiveActionTest extends
168          public FJException(Throwable cause) { super(cause); }
169      }
170  
171 <    // A simple recursive action for testing
171 >    /** A simple recursive action for testing. */
172      final class FibAction extends CheckedRecursiveAction {
173          final int number;
174          int result;
# Line 186 | Line 186 | public class RecursiveActionTest extends
186          }
187      }
188  
189 <    // A recursive action failing in base case
189 >    /** A recursive action failing in base case. */
190      static final class FailingFibAction extends RecursiveAction {
191          final int number;
192          int result;
# Line 258 | Line 258 | public class RecursiveActionTest extends
258          RecursiveAction a = new CheckedRecursiveAction() {
259              protected void realCompute() {
260                  FibAction f = new FibAction(8);
261 <                final Thread myself = Thread.currentThread();
261 >                final Thread currentThread = Thread.currentThread();
262  
263                  // test join()
264                  assertSame(f, f.fork());
265 <                myself.interrupt();
266 <                assertTrue(myself.isInterrupted());
265 >                currentThread.interrupt();
266                  assertNull(f.join());
267                  Thread.interrupted();
268                  assertEquals(21, f.result);
# Line 272 | Line 271 | public class RecursiveActionTest extends
271                  f = new FibAction(8);
272                  f.cancel(true);
273                  assertSame(f, f.fork());
274 <                myself.interrupt();
276 <                assertTrue(myself.isInterrupted());
274 >                currentThread.interrupt();
275                  try {
276                      f.join();
277                      shouldThrow();
# Line 285 | Line 283 | public class RecursiveActionTest extends
283                  f = new FibAction(8);
284                  f.completeExceptionally(new FJException());
285                  assertSame(f, f.fork());
286 <                myself.interrupt();
289 <                assertTrue(myself.isInterrupted());
286 >                currentThread.interrupt();
287                  try {
288                      f.join();
289                      shouldThrow();
# Line 298 | Line 295 | public class RecursiveActionTest extends
295                  // test quietlyJoin()
296                  f = new FibAction(8);
297                  assertSame(f, f.fork());
298 <                myself.interrupt();
302 <                assertTrue(myself.isInterrupted());
298 >                currentThread.interrupt();
299                  f.quietlyJoin();
300                  Thread.interrupted();
301                  assertEquals(21, f.result);
# Line 308 | Line 304 | public class RecursiveActionTest extends
304                  f = new FibAction(8);
305                  f.cancel(true);
306                  assertSame(f, f.fork());
307 <                myself.interrupt();
312 <                assertTrue(myself.isInterrupted());
307 >                currentThread.interrupt();
308                  f.quietlyJoin();
309                  Thread.interrupted();
310                  checkCancelled(f);
# Line 317 | Line 312 | public class RecursiveActionTest extends
312                  f = new FibAction(8);
313                  f.completeExceptionally(new FJException());
314                  assertSame(f, f.fork());
315 <                myself.interrupt();
321 <                assertTrue(myself.isInterrupted());
315 >                currentThread.interrupt();
316                  f.quietlyJoin();
317                  Thread.interrupted();
318                  checkCompletedAbnormally(f, f.getException());
# Line 358 | Line 352 | public class RecursiveActionTest extends
352              public void realRun() throws InterruptedException {
353                  FibAction[] fibActions = sq.take();
354                  FibAction f;
355 <                final Thread myself = Thread.currentThread();
355 >                final Thread currentThread = Thread.currentThread();
356  
357                  // test join() ------------
358  
359                  f = fibActions[0];
360                  assertFalse(ForkJoinTask.inForkJoinPool());
361 <                myself.interrupt();
368 <                assertTrue(myself.isInterrupted());
361 >                currentThread.interrupt();
362                  assertNull(f.join());
363                  assertTrue(Thread.interrupted());
364                  assertEquals(21, f.result);
365                  checkCompletedNormally(f);
366  
367                  f = fibActions[1];
368 <                myself.interrupt();
376 <                assertTrue(myself.isInterrupted());
368 >                currentThread.interrupt();
369                  try {
370                      f.join();
371                      shouldThrow();
# Line 383 | Line 375 | public class RecursiveActionTest extends
375                  }
376  
377                  f = fibActions[2];
378 <                myself.interrupt();
387 <                assertTrue(myself.isInterrupted());
378 >                currentThread.interrupt();
379                  try {
380                      f.join();
381                      shouldThrow();
# Line 396 | Line 387 | public class RecursiveActionTest extends
387                  // test quietlyJoin() ---------
388  
389                  f = fibActions[3];
390 <                myself.interrupt();
400 <                assertTrue(myself.isInterrupted());
390 >                currentThread.interrupt();
391                  f.quietlyJoin();
392                  assertTrue(Thread.interrupted());
393                  assertEquals(21, f.result);
394                  checkCompletedNormally(f);
395  
396                  f = fibActions[4];
397 <                myself.interrupt();
408 <                assertTrue(myself.isInterrupted());
397 >                currentThread.interrupt();
398                  f.quietlyJoin();
399                  assertTrue(Thread.interrupted());
400                  checkCancelled(f);
401  
402                  f = fibActions[5];
403 <                myself.interrupt();
415 <                assertTrue(myself.isInterrupted());
403 >                currentThread.interrupt();
404                  f.quietlyJoin();
405                  assertTrue(Thread.interrupted());
406                  assertTrue(f.getException() instanceof FJException);
# Line 423 | Line 411 | public class RecursiveActionTest extends
411  
412          t = newStartedThread(r);
413          testInvokeOnPool(mainPool(), a);
414 <        awaitTermination(t, LONG_DELAY_MS);
414 >        awaitTermination(t);
415  
416          a.reinitialize();
417          t = newStartedThread(r);
418          testInvokeOnPool(singletonPool(), a);
419 <        awaitTermination(t, LONG_DELAY_MS);
419 >        awaitTermination(t);
420      }
421  
422      /**
# Line 502 | Line 490 | public class RecursiveActionTest extends
490                  FibAction f = new FibAction(8);
491                  assertSame(f, f.fork());
492                  helpQuiesce();
493 +                while (!f.isDone()) // wait out race
494 +                    ;
495                  assertEquals(21, f.result);
496                  assertEquals(0, getQueuedTaskCount());
497                  checkCompletedNormally(f);
# Line 587 | Line 577 | public class RecursiveActionTest extends
577                  FailingFibAction f = new FailingFibAction(8);
578                  assertSame(f, f.fork());
579                  try {
580 <                    f.get(5L, TimeUnit.SECONDS);
580 >                    f.get(5L, SECONDS);
581                      shouldThrow();
582                  } catch (ExecutionException success) {
583                      Throwable cause = success.getCause();

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines