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

Comparing jsr166/src/test/tck/RecursiveTaskTest.java (file contents):
Revision 1.21 by jsr166, Sun Nov 21 08:35:40 2010 UTC vs.
Revision 1.33 by jsr166, Sun Oct 4 18:28:51 2015 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.*;
7 > import static java.util.concurrent.TimeUnit.SECONDS;
8 >
9 > import java.util.HashSet;
10   import java.util.concurrent.CancellationException;
11   import java.util.concurrent.ExecutionException;
12   import java.util.concurrent.ForkJoinPool;
13 < import java.util.concurrent.ForkJoinWorkerThread;
13 > import java.util.concurrent.ForkJoinTask;
14   import java.util.concurrent.RecursiveTask;
13 – import java.util.concurrent.TimeUnit;
15   import java.util.concurrent.TimeoutException;
16 < import static java.util.concurrent.TimeUnit.SECONDS;
17 < import java.util.HashSet;
16 >
17 > import junit.framework.Test;
18 > import junit.framework.TestSuite;
19  
20   public class RecursiveTaskTest extends JSR166TestCase {
21  
22      public static void main(String[] args) {
23 <        junit.textui.TestRunner.run(suite());
23 >        main(suite(), args);
24      }
25      public static Test suite() {
26          return new TestSuite(RecursiveTaskTest.class);
# Line 39 | Line 41 | public class RecursiveTaskTest extends J
41      }
42  
43      private <T> T testInvokeOnPool(ForkJoinPool pool, RecursiveTask<T> a) {
44 <        try {
44 >        try (PoolCleaner cleaner = cleaner(pool)) {
45              checkNotDone(a);
46  
47              T result = pool.invoke(a);
48  
49              checkCompletedNormally(a, result);
50              return result;
49 –        } finally {
50 –            joinPool(pool);
51          }
52      }
53  
# Line 59 | Line 59 | public class RecursiveTaskTest extends J
59          assertNull(a.getException());
60          assertNull(a.getRawResult());
61  
62 <        if (! (Thread.currentThread() instanceof ForkJoinWorkerThread)) {
62 >        if (! ForkJoinTask.inForkJoinPool()) {
63              Thread.currentThread().interrupt();
64              try {
65                  a.get();
# Line 90 | Line 90 | public class RecursiveTaskTest extends J
90          assertNull(a.getException());
91          assertSame(expected, a.getRawResult());
92          assertSame(expected, a.join());
93 +        assertFalse(a.cancel(false));
94 +        assertFalse(a.cancel(true));
95          try {
96              assertSame(expected, a.get());
97          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 145 | Line 147 | public class RecursiveTaskTest extends J
147          } catch (Throwable fail) { threadUnexpectedException(fail); }
148      }
149  
150 <    void checkTaskThrew(RecursiveTask a, Throwable t) {
150 >    void checkCompletedAbnormally(RecursiveTask a, Throwable t) {
151          assertTrue(a.isDone());
152          assertFalse(a.isCancelled());
153          assertFalse(a.isCompletedNormally());
154          assertTrue(a.isCompletedAbnormally());
155 <        assertSame(t, a.getException());
155 >        assertSame(t.getClass(), a.getException().getClass());
156          assertNull(a.getRawResult());
157 +        assertFalse(a.cancel(false));
158 +        assertFalse(a.cancel(true));
159  
160          try {
161              a.join();
162              shouldThrow();
163          } catch (Throwable expected) {
164 <            assertSame(t, expected);
164 >            assertSame(t.getClass(), expected.getClass());
165          }
166  
167          try {
168              a.get();
169              shouldThrow();
170          } catch (ExecutionException success) {
171 <            assertSame(t, success.getCause());
171 >            assertSame(t.getClass(), success.getCause().getClass());
172          } catch (Throwable fail) { threadUnexpectedException(fail); }
173  
174          try {
175              a.get(5L, SECONDS);
176              shouldThrow();
177          } catch (ExecutionException success) {
178 <            assertSame(t, success.getCause());
178 >            assertSame(t.getClass(), success.getCause().getClass());
179          } catch (Throwable fail) { threadUnexpectedException(fail); }
180      }
181  
182 <    static final class FJException extends RuntimeException {
183 <        FJException() { super(); }
182 >    public static final class FJException extends RuntimeException {
183 >        public FJException() { super(); }
184      }
185  
186      // An invalid return value for Fib
# Line 314 | Line 318 | public class RecursiveTaskTest extends J
318          assertEquals(21, (int) testInvokeOnPool(mainPool(), a));
319      }
320  
317 –
321      /**
322       * helpQuiesce returns when tasks are complete.
323       * getQueuedTaskCount returns 0 when quiescent
# Line 324 | Line 327 | public class RecursiveTaskTest extends J
327              public Integer realCompute() {
328                  FibTask f = new FibTask(8);
329                  assertSame(f, f.fork());
330 <                f.helpQuiesce();
330 >                helpQuiesce();
331                  assertEquals(0, getQueuedTaskCount());
332                  checkCompletedNormally(f, 21);
333                  return NoResult;
# Line 332 | Line 335 | public class RecursiveTaskTest extends J
335          assertSame(NoResult, testInvokeOnPool(mainPool(), a));
336      }
337  
335 –
338      /**
339       * invoke task throws exception when task completes abnormally
340       */
# Line 344 | Line 346 | public class RecursiveTaskTest extends J
346                      f.invoke();
347                      shouldThrow();
348                  } catch (FJException success) {
349 <                    checkTaskThrew(f, success);
349 >                    checkCompletedAbnormally(f, success);
350                  }
351                  return NoResult;
352              }};
# Line 360 | Line 362 | public class RecursiveTaskTest extends J
362                  FailingFibTask f = new FailingFibTask(8);
363                  f.quietlyInvoke();
364                  assertTrue(f.getException() instanceof FJException);
365 <                checkTaskThrew(f, f.getException());
365 >                checkCompletedAbnormally(f, f.getException());
366                  return NoResult;
367              }};
368          assertSame(NoResult, testInvokeOnPool(mainPool(), a));
# Line 378 | Line 380 | public class RecursiveTaskTest extends J
380                      Integer r = f.join();
381                      shouldThrow();
382                  } catch (FJException success) {
383 <                    checkTaskThrew(f, success);
383 >                    checkCompletedAbnormally(f, success);
384                  }
385                  return NoResult;
386              }};
# Line 397 | Line 399 | public class RecursiveTaskTest extends J
399                      Integer r = f.get();
400                      shouldThrow();
401                  } catch (ExecutionException success) {
402 <                    checkTaskThrew(f, success.getCause());
402 >                    Throwable cause = success.getCause();
403 >                    assertTrue(cause instanceof FJException);
404 >                    checkCompletedAbnormally(f, cause);
405                  }
406                  return NoResult;
407              }};
# Line 416 | Line 420 | public class RecursiveTaskTest extends J
420                      Integer r = f.get(5L, SECONDS);
421                      shouldThrow();
422                  } catch (ExecutionException success) {
423 <                    checkTaskThrew(f, success.getCause());
423 >                    Throwable cause = success.getCause();
424 >                    assertTrue(cause instanceof FJException);
425 >                    checkCompletedAbnormally(f, cause);
426                  }
427                  return NoResult;
428              }};
# Line 433 | Line 439 | public class RecursiveTaskTest extends J
439                  assertSame(f, f.fork());
440                  f.quietlyJoin();
441                  assertTrue(f.getException() instanceof FJException);
442 <                checkTaskThrew(f, f.getException());
442 >                checkCompletedAbnormally(f, f.getException());
443                  return NoResult;
444              }};
445          assertSame(NoResult, testInvokeOnPool(mainPool(), a));
# Line 577 | Line 583 | public class RecursiveTaskTest extends J
583      public void testInForkJoinPool2() {
584          RecursiveTask<Integer> a = new CheckedRecursiveTask<Integer>() {
585              public Integer realCompute() {
586 <                assertTrue(!inForkJoinPool());
586 >                assertFalse(inForkJoinPool());
587                  return NoResult;
588              }};
589          assertSame(NoResult, a.invoke());
# Line 594 | Line 600 | public class RecursiveTaskTest extends J
600                  return NoResult;
601              }
602          };
603 <        a.invoke();
603 >        assertSame(NoResult, a.invoke());
604      }
605  
606      /**
# Line 633 | Line 639 | public class RecursiveTaskTest extends J
639                          f.invoke();
640                          shouldThrow();
641                      } catch (FJException success) {
642 <                        checkTaskThrew(f, success);
642 >                        checkCompletedAbnormally(f, success);
643                      }
644                      f.reinitialize();
645                      checkNotDone(f);
# Line 655 | Line 661 | public class RecursiveTaskTest extends J
661                      Integer r = f.invoke();
662                      shouldThrow();
663                  } catch (FJException success) {
664 <                    checkTaskThrew(f, success);
664 >                    checkCompletedAbnormally(f, success);
665                  }
666                  return NoResult;
667              }};
# Line 754 | Line 760 | public class RecursiveTaskTest extends J
760          assertSame(NoResult, testInvokeOnPool(mainPool(), a));
761      }
762  
757 –
763      /**
764       * invokeAll(tasks) with any null task throws NPE
765       */
# Line 785 | Line 790 | public class RecursiveTaskTest extends J
790                      invokeAll(f, g);
791                      shouldThrow();
792                  } catch (FJException success) {
793 <                    checkTaskThrew(g, success);
793 >                    checkCompletedAbnormally(g, success);
794                  }
795                  return NoResult;
796              }};
# Line 803 | Line 808 | public class RecursiveTaskTest extends J
808                      invokeAll(g);
809                      shouldThrow();
810                  } catch (FJException success) {
811 <                    checkTaskThrew(g, success);
811 >                    checkCompletedAbnormally(g, success);
812                  }
813                  return NoResult;
814              }};
# Line 823 | Line 828 | public class RecursiveTaskTest extends J
828                      invokeAll(f, g, h);
829                      shouldThrow();
830                  } catch (FJException success) {
831 <                    checkTaskThrew(g, success);
831 >                    checkCompletedAbnormally(g, success);
832                  }
833                  return NoResult;
834              }};
# Line 847 | Line 852 | public class RecursiveTaskTest extends J
852                      invokeAll(set);
853                      shouldThrow();
854                  } catch (FJException success) {
855 <                    checkTaskThrew(f, success);
855 >                    checkCompletedAbnormally(f, success);
856                  }
857                  return NoResult;
858              }};
# Line 889 | Line 894 | public class RecursiveTaskTest extends J
894                  assertSame(f, f.fork());
895                  assertTrue(getSurplusQueuedTaskCount() > 0);
896                  helpQuiesce();
897 +                assertEquals(0, getSurplusQueuedTaskCount());
898                  checkCompletedNormally(f, 21);
899                  checkCompletedNormally(g, 34);
900                  checkCompletedNormally(h, 13);

Diff Legend

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