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.51 by jsr166, Wed Aug 24 22:22:39 2016 UTC

# Line 8 | Line 8 | import static java.util.concurrent.TimeU
8   import static java.util.concurrent.TimeUnit.SECONDS;
9  
10   import java.util.Arrays;
11 – import java.util.Collections;
11   import java.util.HashSet;
13 – import java.util.List;
12   import java.util.concurrent.CancellationException;
13   import java.util.concurrent.ExecutionException;
14   import java.util.concurrent.ForkJoinPool;
# Line 263 | Line 261 | public class ForkJoinTaskTest extends JS
261              }
262              return false;
263          }
264 <        
264 >
265          public final void complete() {
266              BinaryAsyncAction a = this;
267              for (;;) {
# Line 340 | Line 338 | public class ForkJoinTaskTest extends JS
338          public final boolean exec() {
339              AsyncFib f = this;
340              int n = f.number;
341 <            if (n > 1) {
342 <                while (n > 1) {
343 <                    AsyncFib p = f;
344 <                    AsyncFib r = new AsyncFib(n - 2);
345 <                    f = new AsyncFib(--n);
346 <                    p.linkSubtasks(r, f);
349 <                    r.fork();
350 <                }
351 <                f.number = n;
341 >            while (n > 1) {
342 >                AsyncFib p = f;
343 >                AsyncFib r = new AsyncFib(n - 2);
344 >                f = new AsyncFib(--n);
345 >                p.linkSubtasks(r, f);
346 >                r.fork();
347              }
348              f.complete();
349              return false;
# Line 368 | Line 363 | public class ForkJoinTaskTest extends JS
363          public final boolean exec() {
364              FailingAsyncFib f = this;
365              int n = f.number;
366 <            if (n > 1) {
367 <                while (n > 1) {
368 <                    FailingAsyncFib p = f;
369 <                    FailingAsyncFib r = new FailingAsyncFib(n - 2);
370 <                    f = new FailingAsyncFib(--n);
371 <                    p.linkSubtasks(r, f);
377 <                    r.fork();
378 <                }
379 <                f.number = n;
366 >            while (n > 1) {
367 >                FailingAsyncFib p = f;
368 >                FailingAsyncFib r = new FailingAsyncFib(n - 2);
369 >                f = new FailingAsyncFib(--n);
370 >                p.linkSubtasks(r, f);
371 >                r.fork();
372              }
373              f.complete();
374              return false;
# Line 782 | Line 774 | public class ForkJoinTaskTest extends JS
774      }
775  
776      /**
777 +     * completeExceptionally(null) surprisingly has the same effect as
778 +     * completeExceptionally(new RuntimeException())
779 +     */
780 +    public void testCompleteExceptionally_null() {
781 +        RecursiveAction a = new CheckedRecursiveAction() {
782 +            protected void realCompute() {
783 +                AsyncFib f = new AsyncFib(8);
784 +                f.completeExceptionally(null);
785 +                try {
786 +                    f.invoke();
787 +                    shouldThrow();
788 +                } catch (RuntimeException success) {
789 +                    assertSame(success.getClass(), RuntimeException.class);
790 +                    assertNull(success.getCause());
791 +                    checkCompletedAbnormally(f, success);
792 +                }
793 +            }};
794 +        testInvokeOnPool(mainPool(), a);
795 +    }
796 +
797 +    /**
798       * invokeAll(t1, t2) invokes all task arguments
799       */
800      public void testInvokeAll2() {
# Line 882 | Line 895 | public class ForkJoinTaskTest extends JS
895                  AsyncFib f = new AsyncFib(8);
896                  FailingAsyncFib g = new FailingAsyncFib(9);
897                  ForkJoinTask[] tasks = { f, g };
898 <                Collections.shuffle(Arrays.asList(tasks));
898 >                shuffle(tasks);
899                  try {
900                      invokeAll(tasks);
901                      shouldThrow();
# Line 920 | Line 933 | public class ForkJoinTaskTest extends JS
933                  FailingAsyncFib g = new FailingAsyncFib(9);
934                  AsyncFib h = new AsyncFib(7);
935                  ForkJoinTask[] tasks = { f, g, h };
936 <                Collections.shuffle(Arrays.asList(tasks));
936 >                shuffle(tasks);
937                  try {
938                      invokeAll(tasks);
939                      shouldThrow();
# Line 941 | Line 954 | public class ForkJoinTaskTest extends JS
954                  AsyncFib g = new AsyncFib(9);
955                  AsyncFib h = new AsyncFib(7);
956                  ForkJoinTask[] tasks = { f, g, h };
957 <                List taskList = Arrays.asList(tasks);
945 <                Collections.shuffle(taskList);
957 >                shuffle(tasks);
958                  try {
959 <                    invokeAll(taskList);
959 >                    invokeAll(Arrays.asList(tasks));
960                      shouldThrow();
961                  } catch (FJException success) {
962                      checkCompletedAbnormally(f, success);
# Line 1552 | Line 1564 | public class ForkJoinTaskTest extends JS
1564                  AsyncFib f = new AsyncFib(8);
1565                  FailingAsyncFib g = new FailingAsyncFib(9);
1566                  ForkJoinTask[] tasks = { f, g };
1567 <                Collections.shuffle(Arrays.asList(tasks));
1567 >                shuffle(tasks);
1568                  try {
1569                      invokeAll(tasks);
1570                      shouldThrow();
# Line 1590 | Line 1602 | public class ForkJoinTaskTest extends JS
1602                  FailingAsyncFib g = new FailingAsyncFib(9);
1603                  AsyncFib h = new AsyncFib(7);
1604                  ForkJoinTask[] tasks = { f, g, h };
1605 <                Collections.shuffle(Arrays.asList(tasks));
1605 >                shuffle(tasks);
1606                  try {
1607                      invokeAll(tasks);
1608                      shouldThrow();
# Line 1611 | Line 1623 | public class ForkJoinTaskTest extends JS
1623                  AsyncFib g = new AsyncFib(9);
1624                  AsyncFib h = new AsyncFib(7);
1625                  ForkJoinTask[] tasks = { f, g, h };
1626 <                List taskList = Arrays.asList(tasks);
1615 <                Collections.shuffle(taskList);
1626 >                shuffle(tasks);
1627                  try {
1628 <                    invokeAll(taskList);
1628 >                    invokeAll(Arrays.asList(tasks));
1629                      shouldThrow();
1630                  } catch (FJException success) {
1631                      checkCompletedAbnormally(f, success);

Diff Legend

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