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.49 by jsr166, Sat Mar 18 18:20:00 2017 UTC

# 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 170 | 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 188 | 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 260 | 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();
268 <                assertTrue(myself.isInterrupted());
265 >                currentThread.interrupt();
266                  assertNull(f.join());
267                  Thread.interrupted();
268                  assertEquals(21, f.result);
# Line 274 | Line 271 | public class RecursiveActionTest extends
271                  f = new FibAction(8);
272                  f.cancel(true);
273                  assertSame(f, f.fork());
274 <                myself.interrupt();
278 <                assertTrue(myself.isInterrupted());
274 >                currentThread.interrupt();
275                  try {
276                      f.join();
277                      shouldThrow();
# Line 287 | Line 283 | public class RecursiveActionTest extends
283                  f = new FibAction(8);
284                  f.completeExceptionally(new FJException());
285                  assertSame(f, f.fork());
286 <                myself.interrupt();
291 <                assertTrue(myself.isInterrupted());
286 >                currentThread.interrupt();
287                  try {
288                      f.join();
289                      shouldThrow();
# Line 300 | Line 295 | public class RecursiveActionTest extends
295                  // test quietlyJoin()
296                  f = new FibAction(8);
297                  assertSame(f, f.fork());
298 <                myself.interrupt();
304 <                assertTrue(myself.isInterrupted());
298 >                currentThread.interrupt();
299                  f.quietlyJoin();
300                  Thread.interrupted();
301                  assertEquals(21, f.result);
# Line 310 | Line 304 | public class RecursiveActionTest extends
304                  f = new FibAction(8);
305                  f.cancel(true);
306                  assertSame(f, f.fork());
307 <                myself.interrupt();
314 <                assertTrue(myself.isInterrupted());
307 >                currentThread.interrupt();
308                  f.quietlyJoin();
309                  Thread.interrupted();
310                  checkCancelled(f);
# Line 319 | Line 312 | public class RecursiveActionTest extends
312                  f = new FibAction(8);
313                  f.completeExceptionally(new FJException());
314                  assertSame(f, f.fork());
315 <                myself.interrupt();
323 <                assertTrue(myself.isInterrupted());
315 >                currentThread.interrupt();
316                  f.quietlyJoin();
317                  Thread.interrupted();
318                  checkCompletedAbnormally(f, f.getException());
# Line 360 | 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();
370 <                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();
378 <                assertTrue(myself.isInterrupted());
368 >                currentThread.interrupt();
369                  try {
370                      f.join();
371                      shouldThrow();
# Line 385 | Line 375 | public class RecursiveActionTest extends
375                  }
376  
377                  f = fibActions[2];
378 <                myself.interrupt();
389 <                assertTrue(myself.isInterrupted());
378 >                currentThread.interrupt();
379                  try {
380                      f.join();
381                      shouldThrow();
# Line 398 | Line 387 | public class RecursiveActionTest extends
387                  // test quietlyJoin() ---------
388  
389                  f = fibActions[3];
390 <                myself.interrupt();
402 <                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();
410 <                assertTrue(myself.isInterrupted());
397 >                currentThread.interrupt();
398                  f.quietlyJoin();
399                  assertTrue(Thread.interrupted());
400                  checkCancelled(f);
401  
402                  f = fibActions[5];
403 <                myself.interrupt();
417 <                assertTrue(myself.isInterrupted());
403 >                currentThread.interrupt();
404                  f.quietlyJoin();
405                  assertTrue(Thread.interrupted());
406                  assertTrue(f.getException() instanceof FJException);
# Line 425 | 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      /**

Diff Legend

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