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.49 by jsr166, Sun Oct 18 16:40:57 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 467 | 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 897 | 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 935 | 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 956 | 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);
960 <                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 1215 | 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 1567 | 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 1605 | 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 1626 | 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);
1630 <                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