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

Comparing jsr166/src/test/tck/ForkJoinTaskTest.java (file contents):
Revision 1.44 by jsr166, Tue Oct 6 00:36:55 2015 UTC vs.
Revision 1.52 by jsr166, Mon May 29 19:15:02 2017 UTC

# Line 5 | Line 5
5   */
6  
7   import static java.util.concurrent.TimeUnit.MILLISECONDS;
8 – import static java.util.concurrent.TimeUnit.SECONDS;
8  
9 + import java.util.Arrays;
10   import java.util.HashSet;
11   import java.util.concurrent.CancellationException;
12   import java.util.concurrent.ExecutionException;
# Line 76 | Line 76 | public class ForkJoinTaskTest extends JS
76          assertNull(a.getRawResult());
77  
78          try {
79 <            a.get(0L, SECONDS);
79 >            a.get(randomExpiredTimeout(), randomTimeUnit());
80              shouldThrow();
81          } catch (TimeoutException success) {
82          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 98 | Line 98 | public class ForkJoinTaskTest extends JS
98              Thread.currentThread().interrupt();
99              long startTime = System.nanoTime();
100              assertSame(expected, a.join());
101 <            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
101 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
102              Thread.interrupted();
103          }
104  
# Line 106 | Line 106 | public class ForkJoinTaskTest extends JS
106              Thread.currentThread().interrupt();
107              long startTime = System.nanoTime();
108              a.quietlyJoin();        // should be no-op
109 <            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
109 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
110              Thread.interrupted();
111          }
112  
# Line 114 | Line 114 | public class ForkJoinTaskTest extends JS
114          assertFalse(a.cancel(true));
115          try {
116              assertSame(expected, a.get());
117 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
118 <        try {
119 <            assertSame(expected, a.get(5L, SECONDS));
117 >            assertSame(expected, a.get(randomTimeout(), randomTimeUnit()));
118          } catch (Throwable fail) { threadUnexpectedException(fail); }
119      }
120  
# Line 141 | Line 139 | public class ForkJoinTaskTest extends JS
139          {
140              long startTime = System.nanoTime();
141              a.quietlyJoin();        // should be no-op
142 <            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
142 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
143          }
144  
145          try {
# Line 151 | Line 149 | public class ForkJoinTaskTest extends JS
149          } catch (Throwable fail) { threadUnexpectedException(fail); }
150  
151          try {
152 <            a.get(5L, SECONDS);
152 >            a.get(randomTimeout(), randomTimeUnit());
153              shouldThrow();
154          } catch (CancellationException success) {
155          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 179 | Line 177 | public class ForkJoinTaskTest extends JS
177          {
178              long startTime = System.nanoTime();
179              a.quietlyJoin();        // should be no-op
180 <            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
180 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
181          }
182  
183          try {
# Line 190 | Line 188 | public class ForkJoinTaskTest extends JS
188          } catch (Throwable fail) { threadUnexpectedException(fail); }
189  
190          try {
191 <            a.get(5L, SECONDS);
191 >            a.get(randomTimeout(), randomTimeUnit());
192              shouldThrow();
193          } catch (ExecutionException success) {
194              assertSame(t.getClass(), success.getCause().getClass());
# Line 253 | Line 251 | public class ForkJoinTaskTest extends JS
251              super.completeExceptionally(ex);
252          }
253  
254 +        public boolean cancel(boolean mayInterruptIfRunning) {
255 +            if (super.cancel(mayInterruptIfRunning)) {
256 +                completeExceptionally(new FJException());
257 +                return true;
258 +            }
259 +            return false;
260 +        }
261 +
262          public final void complete() {
263              BinaryAsyncAction a = this;
264              for (;;) {
# Line 274 | Line 280 | public class ForkJoinTaskTest extends JS
280          }
281  
282          public final void completeExceptionally(Throwable ex) {
283 <            BinaryAsyncAction a = this;
278 <            while (!a.isCompletedAbnormally()) {
283 >            for (BinaryAsyncAction a = this;;) {
284                  a.completeThisExceptionally(ex);
285                  BinaryAsyncAction s = a.sibling;
286 <                if (s != null)
287 <                    s.cancel(false);
288 <                if (!a.onException() || (a = a.parent) == null)
286 >                if (s != null && !s.isDone())
287 >                    s.completeExceptionally(ex);
288 >                if ((a = a.parent) == null)
289                      break;
290              }
291          }
# Line 330 | Line 335 | public class ForkJoinTaskTest extends JS
335          public final boolean exec() {
336              AsyncFib f = this;
337              int n = f.number;
338 <            if (n > 1) {
339 <                while (n > 1) {
340 <                    AsyncFib p = f;
341 <                    AsyncFib r = new AsyncFib(n - 2);
342 <                    f = new AsyncFib(--n);
343 <                    p.linkSubtasks(r, f);
339 <                    r.fork();
340 <                }
341 <                f.number = n;
338 >            while (n > 1) {
339 >                AsyncFib p = f;
340 >                AsyncFib r = new AsyncFib(n - 2);
341 >                f = new AsyncFib(--n);
342 >                p.linkSubtasks(r, f);
343 >                r.fork();
344              }
345              f.complete();
346              return false;
# Line 358 | Line 360 | public class ForkJoinTaskTest extends JS
360          public final boolean exec() {
361              FailingAsyncFib f = this;
362              int n = f.number;
363 <            if (n > 1) {
364 <                while (n > 1) {
365 <                    FailingAsyncFib p = f;
366 <                    FailingAsyncFib r = new FailingAsyncFib(n - 2);
367 <                    f = new FailingAsyncFib(--n);
368 <                    p.linkSubtasks(r, f);
367 <                    r.fork();
368 <                }
369 <                f.number = n;
363 >            while (n > 1) {
364 >                FailingAsyncFib p = f;
365 >                FailingAsyncFib r = new FailingAsyncFib(n - 2);
366 >                f = new FailingAsyncFib(--n);
367 >                p.linkSubtasks(r, f);
368 >                r.fork();
369              }
370              f.complete();
371              return false;
# Line 463 | Line 462 | public class ForkJoinTaskTest extends JS
462                  AsyncFib f = new AsyncFib(8);
463                  assertSame(f, f.fork());
464                  try {
465 <                    f.get(5L, null);
465 >                    f.get(randomTimeout(), null);
466                      shouldThrow();
467                  } catch (NullPointerException success) {}
468              }};
# Line 772 | Line 771 | public class ForkJoinTaskTest extends JS
771      }
772  
773      /**
774 +     * completeExceptionally(null) surprisingly has the same effect as
775 +     * completeExceptionally(new RuntimeException())
776 +     */
777 +    public void testCompleteExceptionally_null() {
778 +        RecursiveAction a = new CheckedRecursiveAction() {
779 +            protected void realCompute() {
780 +                AsyncFib f = new AsyncFib(8);
781 +                f.completeExceptionally(null);
782 +                try {
783 +                    f.invoke();
784 +                    shouldThrow();
785 +                } catch (RuntimeException success) {
786 +                    assertSame(success.getClass(), RuntimeException.class);
787 +                    assertNull(success.getCause());
788 +                    checkCompletedAbnormally(f, success);
789 +                }
790 +            }};
791 +        testInvokeOnPool(mainPool(), a);
792 +    }
793 +
794 +    /**
795       * invokeAll(t1, t2) invokes all task arguments
796       */
797      public void testInvokeAll2() {
# Line 871 | Line 891 | public class ForkJoinTaskTest extends JS
891              protected void realCompute() {
892                  AsyncFib f = new AsyncFib(8);
893                  FailingAsyncFib g = new FailingAsyncFib(9);
894 +                ForkJoinTask[] tasks = { f, g };
895 +                shuffle(tasks);
896                  try {
897 <                    invokeAll(f, g);
897 >                    invokeAll(tasks);
898                      shouldThrow();
899                  } catch (FJException success) {
900                      checkCompletedAbnormally(g, success);
# Line 907 | Line 929 | public class ForkJoinTaskTest extends JS
929                  AsyncFib f = new AsyncFib(8);
930                  FailingAsyncFib g = new FailingAsyncFib(9);
931                  AsyncFib h = new AsyncFib(7);
932 +                ForkJoinTask[] tasks = { f, g, h };
933 +                shuffle(tasks);
934                  try {
935 <                    invokeAll(f, g, h);
935 >                    invokeAll(tasks);
936                      shouldThrow();
937                  } catch (FJException success) {
938                      checkCompletedAbnormally(g, success);
# Line 926 | Line 950 | public class ForkJoinTaskTest extends JS
950                  FailingAsyncFib f = new FailingAsyncFib(8);
951                  AsyncFib g = new AsyncFib(9);
952                  AsyncFib h = new AsyncFib(7);
953 <                HashSet set = new HashSet();
954 <                set.add(f);
931 <                set.add(g);
932 <                set.add(h);
953 >                ForkJoinTask[] tasks = { f, g, h };
954 >                shuffle(tasks);
955                  try {
956 <                    invokeAll(set);
956 >                    invokeAll(Arrays.asList(tasks));
957                      shouldThrow();
958                  } catch (FJException success) {
959                      checkCompletedAbnormally(f, success);
# Line 1187 | Line 1209 | public class ForkJoinTaskTest extends JS
1209                  AsyncFib f = new AsyncFib(8);
1210                  assertSame(f, f.fork());
1211                  try {
1212 <                    f.get(5L, null);
1212 >                    f.get(randomTimeout(), null);
1213                      shouldThrow();
1214                  } catch (NullPointerException success) {}
1215              }};
# Line 1538 | Line 1560 | public class ForkJoinTaskTest extends JS
1560              protected void realCompute() {
1561                  AsyncFib f = new AsyncFib(8);
1562                  FailingAsyncFib g = new FailingAsyncFib(9);
1563 +                ForkJoinTask[] tasks = { f, g };
1564 +                shuffle(tasks);
1565                  try {
1566 <                    invokeAll(f, g);
1566 >                    invokeAll(tasks);
1567                      shouldThrow();
1568                  } catch (FJException success) {
1569                      checkCompletedAbnormally(g, success);
# Line 1574 | Line 1598 | public class ForkJoinTaskTest extends JS
1598                  AsyncFib f = new AsyncFib(8);
1599                  FailingAsyncFib g = new FailingAsyncFib(9);
1600                  AsyncFib h = new AsyncFib(7);
1601 +                ForkJoinTask[] tasks = { f, g, h };
1602 +                shuffle(tasks);
1603                  try {
1604 <                    invokeAll(f, g, h);
1604 >                    invokeAll(tasks);
1605                      shouldThrow();
1606                  } catch (FJException success) {
1607                      checkCompletedAbnormally(g, success);
# Line 1593 | Line 1619 | public class ForkJoinTaskTest extends JS
1619                  FailingAsyncFib f = new FailingAsyncFib(8);
1620                  AsyncFib g = new AsyncFib(9);
1621                  AsyncFib h = new AsyncFib(7);
1622 <                HashSet set = new HashSet();
1623 <                set.add(f);
1598 <                set.add(g);
1599 <                set.add(h);
1622 >                ForkJoinTask[] tasks = { f, g, h };
1623 >                shuffle(tasks);
1624                  try {
1625 <                    invokeAll(set);
1625 >                    invokeAll(Arrays.asList(tasks));
1626                      shouldThrow();
1627                  } catch (FJException success) {
1628                      checkCompletedAbnormally(f, success);

Diff Legend

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