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

Comparing jsr166/src/test/tck/ForkJoinTask8Test.java (file contents):
Revision 1.23 by dl, Sun Oct 11 13:30:30 2015 UTC vs.
Revision 1.32 by jsr166, Sun Jul 22 20:42:51 2018 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.concurrent.CountDownLatch;
11   import java.util.concurrent.ExecutionException;
12   import java.util.concurrent.ForkJoinPool;
# Line 101 | Line 99 | public class ForkJoinTask8Test extends J
99          assertNull(a.getException());
100          assertNull(a.getRawResult());
101          if (a instanceof BinaryAsyncAction)
102 <            assertTrue(((BinaryAsyncAction)a).getForkJoinTaskTag() == INITIAL_STATE);
102 >            assertEquals(INITIAL_STATE,
103 >                         ((BinaryAsyncAction)a).getForkJoinTaskTag());
104  
105          try {
106 <            a.get(0L, SECONDS);
106 >            a.get(randomExpiredTimeout(), randomTimeUnit());
107              shouldThrow();
108          } catch (TimeoutException success) {
109          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 114 | Line 113 | public class ForkJoinTask8Test extends J
113          checkCompletedNormally(a, null);
114      }
115  
116 <    <T> void checkCompletedNormally(ForkJoinTask<T> a, T expected) {
116 >    <T> void checkCompletedNormally(ForkJoinTask<T> a, T expectedValue) {
117          assertTrue(a.isDone());
118          assertFalse(a.isCancelled());
119          assertTrue(a.isCompletedNormally());
120          assertFalse(a.isCompletedAbnormally());
121          assertNull(a.getException());
122 <        assertSame(expected, a.getRawResult());
122 >        assertSame(expectedValue, a.getRawResult());
123          if (a instanceof BinaryAsyncAction)
124 <            assertTrue(((BinaryAsyncAction)a).getForkJoinTaskTag() == COMPLETE_STATE);
124 >            assertEquals(COMPLETE_STATE,
125 >                         ((BinaryAsyncAction)a).getForkJoinTaskTag());
126  
127          {
128              Thread.currentThread().interrupt();
129              long startTime = System.nanoTime();
130 <            assertSame(expected, a.join());
131 <            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
130 >            assertSame(expectedValue, a.join());
131 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
132              Thread.interrupted();
133          }
134  
# Line 136 | Line 136 | public class ForkJoinTask8Test extends J
136              Thread.currentThread().interrupt();
137              long startTime = System.nanoTime();
138              a.quietlyJoin();        // should be no-op
139 <            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
139 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
140              Thread.interrupted();
141          }
142  
143          assertFalse(a.cancel(false));
144          assertFalse(a.cancel(true));
145 +
146 +        T v1 = null, v2 = null;
147          try {
148 <            assertSame(expected, a.get());
149 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
148 <        try {
149 <            assertSame(expected, a.get(5L, SECONDS));
148 >            v1 = a.get();
149 >            v2 = a.get(randomTimeout(), randomTimeUnit());
150          } catch (Throwable fail) { threadUnexpectedException(fail); }
151 +        assertSame(expectedValue, v1);
152 +        assertSame(expectedValue, v2);
153      }
154  
155      void checkCompletedAbnormally(ForkJoinTask a, Throwable t) {
# Line 174 | Line 176 | public class ForkJoinTask8Test extends J
176          {
177              long startTime = System.nanoTime();
178              a.quietlyJoin();        // should be no-op
179 <            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
179 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
180          }
181  
182          try {
# Line 185 | Line 187 | public class ForkJoinTask8Test extends J
187          } catch (Throwable fail) { threadUnexpectedException(fail); }
188  
189          try {
190 <            a.get(5L, SECONDS);
190 >            a.get(randomTimeout(), randomTimeUnit());
191              shouldThrow();
192          } catch (ExecutionException success) {
193              assertSame(t.getClass(), success.getCause().getClass());
# Line 250 | Line 252 | public class ForkJoinTask8Test extends J
252              }
253              return false;
254          }
255 <        
255 >
256          public final void complete() {
257              BinaryAsyncAction a = this;
258              for (;;) {
# Line 310 | Line 312 | public class ForkJoinTask8Test extends J
312              try {
313                  AsyncFib f = this;
314                  int n = f.number;
315 <                if (n > 1) {
316 <                    while (n > 1) {
317 <                        AsyncFib p = f;
318 <                        AsyncFib r = new AsyncFib(n - 2);
319 <                        f = new AsyncFib(--n);
320 <                        p.linkSubtasks(r, f);
319 <                        r.fork();
320 <                    }
321 <                    f.number = n;
315 >                while (n > 1) {
316 >                    AsyncFib p = f;
317 >                    AsyncFib r = new AsyncFib(n - 2);
318 >                    f = new AsyncFib(--n);
319 >                    p.linkSubtasks(r, f);
320 >                    r.fork();
321                  }
322                  f.complete();
323              }
# Line 351 | Line 350 | public class ForkJoinTask8Test extends J
350              try {
351                  FailingAsyncFib f = this;
352                  int n = f.number;
353 <                if (n > 1) {
354 <                    while (n > 1) {
355 <                        FailingAsyncFib p = f;
356 <                        FailingAsyncFib r = new FailingAsyncFib(n - 2);
357 <                        f = new FailingAsyncFib(--n);
358 <                        p.linkSubtasks(r, f);
360 <                        r.fork();
361 <                    }
362 <                    f.number = n;
353 >                while (n > 1) {
354 >                    FailingAsyncFib p = f;
355 >                    FailingAsyncFib r = new FailingAsyncFib(n - 2);
356 >                    f = new FailingAsyncFib(--n);
357 >                    p.linkSubtasks(r, f);
358 >                    r.fork();
359                  }
360                  f.complete();
361              }
# Line 493 | Line 489 | public class ForkJoinTask8Test extends J
489                  AsyncFib f = new AsyncFib(8);
490                  assertSame(f, f.fork());
491                  try {
492 <                    f.get(5L, null);
492 >                    f.get(randomTimeout(), null);
493                      shouldThrow();
494                  } catch (NullPointerException success) {}
495              }};
# Line 927 | Line 923 | public class ForkJoinTask8Test extends J
923                  AsyncFib f = new AsyncFib(8);
924                  FailingAsyncFib g = new FailingAsyncFib(9);
925                  ForkJoinTask[] tasks = { f, g };
926 <                Collections.shuffle(Arrays.asList(tasks));
926 >                shuffle(tasks);
927                  try {
928                      invokeAll(tasks[0], tasks[1]);
929                      shouldThrow();
# Line 954 | Line 950 | public class ForkJoinTask8Test extends J
950                  FailingAsyncFib g = new FailingAsyncFib(9);
951                  AsyncFib h = new AsyncFib(7);
952                  ForkJoinTask[] tasks = { f, g, h };
953 <                Collections.shuffle(Arrays.asList(tasks));
953 >                shuffle(tasks);
954                  try {
955                      invokeAll(tasks[0], tasks[1], tasks[2]);
956                      shouldThrow();
# Line 981 | Line 977 | public class ForkJoinTask8Test extends J
977                  AsyncFib g = new AsyncFib(9);
978                  AsyncFib h = new AsyncFib(7);
979                  ForkJoinTask[] tasks = { f, g, h };
980 <                Collections.shuffle(Arrays.asList(tasks));
980 >                shuffle(tasks);
981                  try {
982                      invokeAll(Arrays.asList(tasks));
983                      shouldThrow();

Diff Legend

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