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.44 by jsr166, Sat Apr 25 04:55:31 2015 UTC vs.
Revision 1.54 by jsr166, Mon May 28 21:49:32 2018 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 < import static java.util.concurrent.TimeUnit.SECONDS;
7 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
8  
9   import java.util.Arrays;
10   import java.util.HashSet;
# Line 46 | 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);
55 –        } finally {
56 –            joinPool(pool);
55          }
56      }
57  
# Line 75 | Line 73 | public class RecursiveActionTest extends
73  
74              Thread.currentThread().interrupt();
75              try {
76 <                a.get(5L, SECONDS);
76 >                a.get(randomTimeout(), randomTimeUnit());
77                  shouldThrow();
78              } catch (InterruptedException success) {
79              } catch (Throwable fail) { threadUnexpectedException(fail); }
80          }
81  
82          try {
83 <            a.get(0L, SECONDS);
83 >            a.get(randomExpiredTimeout(), randomTimeUnit());
84              shouldThrow();
85          } catch (TimeoutException success) {
86          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 100 | Line 98 | public class RecursiveActionTest extends
98          assertFalse(a.cancel(true));
99          try {
100              assertNull(a.get());
101 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
104 <        try {
105 <            assertNull(a.get(5L, SECONDS));
101 >            assertNull(a.get(randomTimeout(), randomTimeUnit()));
102          } catch (Throwable fail) { threadUnexpectedException(fail); }
103      }
104  
# Line 127 | Line 123 | public class RecursiveActionTest extends
123          } catch (Throwable fail) { threadUnexpectedException(fail); }
124  
125          try {
126 <            a.get(5L, SECONDS);
126 >            a.get(randomTimeout(), randomTimeUnit());
127              shouldThrow();
128          } catch (CancellationException success) {
129          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 158 | Line 154 | public class RecursiveActionTest extends
154          } catch (Throwable fail) { threadUnexpectedException(fail); }
155  
156          try {
157 <            a.get(5L, SECONDS);
157 >            a.get(randomTimeout(), randomTimeUnit());
158              shouldThrow();
159          } catch (ExecutionException success) {
160              assertSame(t.getClass(), success.getCause().getClass());
# Line 170 | Line 166 | public class RecursiveActionTest extends
166          public FJException(Throwable cause) { super(cause); }
167      }
168  
169 <    // A simple recursive action for testing
169 >    /** A simple recursive action for testing. */
170      final class FibAction extends CheckedRecursiveAction {
171          final int number;
172          int result;
# Line 188 | Line 184 | public class RecursiveActionTest extends
184          }
185      }
186  
187 <    // A recursive action failing in base case
187 >    /** A recursive action failing in base case. */
188      static final class FailingFibAction extends RecursiveAction {
189          final int number;
190          int result;
# Line 260 | Line 256 | public class RecursiveActionTest extends
256          RecursiveAction a = new CheckedRecursiveAction() {
257              protected void realCompute() {
258                  FibAction f = new FibAction(8);
259 <                final Thread myself = Thread.currentThread();
259 >                final Thread currentThread = Thread.currentThread();
260  
261                  // test join()
262                  assertSame(f, f.fork());
263 <                myself.interrupt();
268 <                assertTrue(myself.isInterrupted());
263 >                currentThread.interrupt();
264                  assertNull(f.join());
265                  Thread.interrupted();
266                  assertEquals(21, f.result);
# Line 274 | Line 269 | public class RecursiveActionTest extends
269                  f = new FibAction(8);
270                  f.cancel(true);
271                  assertSame(f, f.fork());
272 <                myself.interrupt();
278 <                assertTrue(myself.isInterrupted());
272 >                currentThread.interrupt();
273                  try {
274                      f.join();
275                      shouldThrow();
# Line 287 | Line 281 | public class RecursiveActionTest extends
281                  f = new FibAction(8);
282                  f.completeExceptionally(new FJException());
283                  assertSame(f, f.fork());
284 <                myself.interrupt();
291 <                assertTrue(myself.isInterrupted());
284 >                currentThread.interrupt();
285                  try {
286                      f.join();
287                      shouldThrow();
# Line 300 | Line 293 | public class RecursiveActionTest extends
293                  // test quietlyJoin()
294                  f = new FibAction(8);
295                  assertSame(f, f.fork());
296 <                myself.interrupt();
304 <                assertTrue(myself.isInterrupted());
296 >                currentThread.interrupt();
297                  f.quietlyJoin();
298                  Thread.interrupted();
299                  assertEquals(21, f.result);
# Line 310 | Line 302 | public class RecursiveActionTest extends
302                  f = new FibAction(8);
303                  f.cancel(true);
304                  assertSame(f, f.fork());
305 <                myself.interrupt();
314 <                assertTrue(myself.isInterrupted());
305 >                currentThread.interrupt();
306                  f.quietlyJoin();
307                  Thread.interrupted();
308                  checkCancelled(f);
# Line 319 | Line 310 | public class RecursiveActionTest extends
310                  f = new FibAction(8);
311                  f.completeExceptionally(new FJException());
312                  assertSame(f, f.fork());
313 <                myself.interrupt();
323 <                assertTrue(myself.isInterrupted());
313 >                currentThread.interrupt();
314                  f.quietlyJoin();
315                  Thread.interrupted();
316                  checkCompletedAbnormally(f, f.getException());
# Line 335 | Line 325 | public class RecursiveActionTest extends
325       * succeeds in the presence of interrupts
326       */
327      public void testJoinIgnoresInterruptsOutsideForkJoinPool() {
328 <        final SynchronousQueue<FibAction[]> sq =
339 <            new SynchronousQueue<FibAction[]>();
328 >        final SynchronousQueue<FibAction[]> sq = new SynchronousQueue<>();
329          RecursiveAction a = new CheckedRecursiveAction() {
330              protected void realCompute() throws InterruptedException {
331                  FibAction[] fibActions = new FibAction[6];
# Line 348 | Line 337 | public class RecursiveActionTest extends
337                  fibActions[4].cancel(true);
338                  fibActions[5].completeExceptionally(new FJException());
339  
340 <                for (int i = 0; i < fibActions.length; i++)
341 <                    fibActions[i].fork();
340 >                for (FibAction fibAction : fibActions)
341 >                    fibAction.fork();
342  
343                  sq.put(fibActions);
344  
# Line 360 | Line 349 | public class RecursiveActionTest extends
349              public void realRun() throws InterruptedException {
350                  FibAction[] fibActions = sq.take();
351                  FibAction f;
352 <                final Thread myself = Thread.currentThread();
352 >                final Thread currentThread = Thread.currentThread();
353  
354                  // test join() ------------
355  
356                  f = fibActions[0];
357                  assertFalse(ForkJoinTask.inForkJoinPool());
358 <                myself.interrupt();
370 <                assertTrue(myself.isInterrupted());
358 >                currentThread.interrupt();
359                  assertNull(f.join());
360                  assertTrue(Thread.interrupted());
361                  assertEquals(21, f.result);
362                  checkCompletedNormally(f);
363  
364                  f = fibActions[1];
365 <                myself.interrupt();
378 <                assertTrue(myself.isInterrupted());
365 >                currentThread.interrupt();
366                  try {
367                      f.join();
368                      shouldThrow();
# Line 385 | Line 372 | public class RecursiveActionTest extends
372                  }
373  
374                  f = fibActions[2];
375 <                myself.interrupt();
389 <                assertTrue(myself.isInterrupted());
375 >                currentThread.interrupt();
376                  try {
377                      f.join();
378                      shouldThrow();
# Line 398 | Line 384 | public class RecursiveActionTest extends
384                  // test quietlyJoin() ---------
385  
386                  f = fibActions[3];
387 <                myself.interrupt();
402 <                assertTrue(myself.isInterrupted());
387 >                currentThread.interrupt();
388                  f.quietlyJoin();
389                  assertTrue(Thread.interrupted());
390                  assertEquals(21, f.result);
391                  checkCompletedNormally(f);
392  
393                  f = fibActions[4];
394 <                myself.interrupt();
410 <                assertTrue(myself.isInterrupted());
394 >                currentThread.interrupt();
395                  f.quietlyJoin();
396                  assertTrue(Thread.interrupted());
397                  checkCancelled(f);
398  
399                  f = fibActions[5];
400 <                myself.interrupt();
417 <                assertTrue(myself.isInterrupted());
400 >                currentThread.interrupt();
401                  f.quietlyJoin();
402                  assertTrue(Thread.interrupted());
403                  assertTrue(f.getException() instanceof FJException);
# Line 425 | Line 408 | public class RecursiveActionTest extends
408  
409          t = newStartedThread(r);
410          testInvokeOnPool(mainPool(), a);
411 <        awaitTermination(t, LONG_DELAY_MS);
411 >        awaitTermination(t);
412  
413          a.reinitialize();
414          t = newStartedThread(r);
415          testInvokeOnPool(singletonPool(), a);
416 <        awaitTermination(t, LONG_DELAY_MS);
416 >        awaitTermination(t);
417      }
418  
419      /**
# Line 456 | Line 439 | public class RecursiveActionTest extends
439              protected void realCompute() throws Exception {
440                  FibAction f = new FibAction(8);
441                  assertSame(f, f.fork());
442 <                assertNull(f.get(5L, SECONDS));
442 >                assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
443                  assertEquals(21, f.result);
444                  checkCompletedNormally(f);
445              }};
# Line 472 | Line 455 | public class RecursiveActionTest extends
455                  FibAction f = new FibAction(8);
456                  assertSame(f, f.fork());
457                  try {
458 <                    f.get(5L, null);
458 >                    f.get(randomTimeout(), null);
459                      shouldThrow();
460                  } catch (NullPointerException success) {}
461              }};
# Line 591 | Line 574 | public class RecursiveActionTest extends
574                  FailingFibAction f = new FailingFibAction(8);
575                  assertSame(f, f.fork());
576                  try {
577 <                    f.get(5L, SECONDS);
577 >                    f.get(LONG_DELAY_MS, MILLISECONDS);
578                      shouldThrow();
579                  } catch (ExecutionException success) {
580                      Throwable cause = success.getCause();
# Line 683 | Line 666 | public class RecursiveActionTest extends
666                  assertTrue(f.cancel(true));
667                  assertSame(f, f.fork());
668                  try {
669 <                    f.get(5L, SECONDS);
669 >                    f.get(LONG_DELAY_MS, MILLISECONDS);
670                      shouldThrow();
671                  } catch (CancellationException success) {
672                      checkCancelled(f);

Diff Legend

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