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.46 by dl, Sun Oct 11 13:30:30 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;
11 – import java.util.Collections;
10   import java.util.HashSet;
13 – import java.util.List;
11   import java.util.concurrent.CancellationException;
12   import java.util.concurrent.ExecutionException;
13   import java.util.concurrent.ForkJoinPool;
# Line 79 | 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 101 | 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 109 | 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 117 | 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); }
121 <        try {
122 <            assertSame(expected, a.get(5L, SECONDS));
117 >            assertSame(expected, a.get(randomTimeout(), randomTimeUnit()));
118          } catch (Throwable fail) { threadUnexpectedException(fail); }
119      }
120  
# Line 144 | 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 154 | 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 182 | 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 193 | 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 263 | Line 258 | public class ForkJoinTaskTest extends JS
258              }
259              return false;
260          }
261 <        
261 >
262          public final void complete() {
263              BinaryAsyncAction a = this;
264              for (;;) {
# Line 340 | 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);
349 <                    r.fork();
350 <                }
351 <                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 368 | 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);
377 <                    r.fork();
378 <                }
379 <                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 473 | 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 782 | 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 882 | Line 892 | public class ForkJoinTaskTest extends JS
892                  AsyncFib f = new AsyncFib(8);
893                  FailingAsyncFib g = new FailingAsyncFib(9);
894                  ForkJoinTask[] tasks = { f, g };
895 <                Collections.shuffle(Arrays.asList(tasks));
895 >                shuffle(tasks);
896                  try {
897                      invokeAll(tasks);
898                      shouldThrow();
# Line 920 | Line 930 | public class ForkJoinTaskTest extends JS
930                  FailingAsyncFib g = new FailingAsyncFib(9);
931                  AsyncFib h = new AsyncFib(7);
932                  ForkJoinTask[] tasks = { f, g, h };
933 <                Collections.shuffle(Arrays.asList(tasks));
933 >                shuffle(tasks);
934                  try {
935                      invokeAll(tasks);
936                      shouldThrow();
# Line 941 | Line 951 | public class ForkJoinTaskTest extends JS
951                  AsyncFib g = new AsyncFib(9);
952                  AsyncFib h = new AsyncFib(7);
953                  ForkJoinTask[] tasks = { f, g, h };
954 <                List taskList = Arrays.asList(tasks);
945 <                Collections.shuffle(taskList);
954 >                shuffle(tasks);
955                  try {
956 <                    invokeAll(taskList);
956 >                    invokeAll(Arrays.asList(tasks));
957                      shouldThrow();
958                  } catch (FJException success) {
959                      checkCompletedAbnormally(f, success);
# Line 1200 | 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 1552 | Line 1561 | public class ForkJoinTaskTest extends JS
1561                  AsyncFib f = new AsyncFib(8);
1562                  FailingAsyncFib g = new FailingAsyncFib(9);
1563                  ForkJoinTask[] tasks = { f, g };
1564 <                Collections.shuffle(Arrays.asList(tasks));
1564 >                shuffle(tasks);
1565                  try {
1566                      invokeAll(tasks);
1567                      shouldThrow();
# Line 1590 | Line 1599 | public class ForkJoinTaskTest extends JS
1599                  FailingAsyncFib g = new FailingAsyncFib(9);
1600                  AsyncFib h = new AsyncFib(7);
1601                  ForkJoinTask[] tasks = { f, g, h };
1602 <                Collections.shuffle(Arrays.asList(tasks));
1602 >                shuffle(tasks);
1603                  try {
1604                      invokeAll(tasks);
1605                      shouldThrow();
# Line 1611 | Line 1620 | public class ForkJoinTaskTest extends JS
1620                  AsyncFib g = new AsyncFib(9);
1621                  AsyncFib h = new AsyncFib(7);
1622                  ForkJoinTask[] tasks = { f, g, h };
1623 <                List taskList = Arrays.asList(tasks);
1615 <                Collections.shuffle(taskList);
1623 >                shuffle(tasks);
1624                  try {
1625 <                    invokeAll(taskList);
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