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.15 by dl, Tue Sep 8 23:56:19 2015 UTC vs.
Revision 1.28 by jsr166, Sat Mar 18 20:42:20 2017 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.concurrent.CountDownLatch;
12   import java.util.concurrent.ExecutionException;
13   import java.util.concurrent.ForkJoinPool;
# Line 74 | Line 73 | public class ForkJoinTask8Test extends J
73      }
74  
75      private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
76 <        try {
76 >        try (PoolCleaner cleaner = cleaner(pool)) {
77              assertFalse(a.isDone());
78              assertFalse(a.isCompletedNormally());
79              assertFalse(a.isCompletedAbnormally());
# Line 90 | Line 89 | public class ForkJoinTask8Test extends J
89              assertFalse(a.isCancelled());
90              assertNull(a.getException());
91              assertNull(a.getRawResult());
93 –        } finally {
94 –            joinPool(pool);
92          }
93      }
94  
# Line 103 | Line 100 | public class ForkJoinTask8Test extends J
100          assertNull(a.getException());
101          assertNull(a.getRawResult());
102          if (a instanceof BinaryAsyncAction)
103 <            assertTrue(((BinaryAsyncAction)a).getForkJoinTaskTag() == INITIAL_STATE);
103 >            assertEquals(INITIAL_STATE,
104 >                         ((BinaryAsyncAction)a).getForkJoinTaskTag());
105  
106          try {
107              a.get(0L, SECONDS);
# Line 124 | Line 122 | public class ForkJoinTask8Test extends J
122          assertNull(a.getException());
123          assertSame(expected, a.getRawResult());
124          if (a instanceof BinaryAsyncAction)
125 <            assertTrue(((BinaryAsyncAction)a).getForkJoinTaskTag() == COMPLETE_STATE);
125 >            assertEquals(COMPLETE_STATE,
126 >                         ((BinaryAsyncAction)a).getForkJoinTaskTag());
127  
128          {
129              Thread.currentThread().interrupt();
130 <            long t0 = System.nanoTime();
130 >            long startTime = System.nanoTime();
131              assertSame(expected, a.join());
132 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
132 >            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
133              Thread.interrupted();
134          }
135  
136          {
137              Thread.currentThread().interrupt();
138 <            long t0 = System.nanoTime();
138 >            long startTime = System.nanoTime();
139              a.quietlyJoin();        // should be no-op
140 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
140 >            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
141              Thread.interrupted();
142          }
143  
# Line 174 | Line 173 | public class ForkJoinTask8Test extends J
173          Thread.interrupted();
174  
175          {
176 <            long t0 = System.nanoTime();
176 >            long startTime = System.nanoTime();
177              a.quietlyJoin();        // should be no-op
178 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
178 >            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
179          }
180  
181          try {
# Line 200 | Line 199 | public class ForkJoinTask8Test extends J
199  
200      abstract static class BinaryAsyncAction extends ForkJoinTask<Void> {
201  
202 <        private BinaryAsyncAction parent;
202 >        private volatile BinaryAsyncAction parent;
203  
204 <        private BinaryAsyncAction sibling;
204 >        private volatile BinaryAsyncAction sibling;
205  
206          protected BinaryAsyncAction() {
207              setForkJoinTaskTag(INITIAL_STATE);
# Line 245 | Line 244 | public class ForkJoinTask8Test extends J
244              super.completeExceptionally(ex);
245          }
246  
247 +        public boolean cancel(boolean mayInterruptIfRunning) {
248 +            if (super.cancel(mayInterruptIfRunning)) {
249 +                completeExceptionally(new FJException());
250 +                return true;
251 +            }
252 +            return false;
253 +        }
254 +
255          public final void complete() {
256              BinaryAsyncAction a = this;
257              for (;;) {
# Line 267 | Line 274 | public class ForkJoinTask8Test extends J
274          }
275  
276          public final void completeExceptionally(Throwable ex) {
277 <            BinaryAsyncAction a = this;
271 <            while (!a.isCompletedAbnormally()) {
277 >            for (BinaryAsyncAction a = this;;) {
278                  a.completeThisExceptionally(ex);
279                  BinaryAsyncAction s = a.sibling;
280 <                if (s != null)
281 <                    s.cancel(false);
282 <                if (!a.onException() || (a = a.parent) == null)
280 >                if (s != null && !s.isDone())
281 >                    s.completeExceptionally(ex);
282 >                if ((a = a.parent) == null)
283                      break;
284              }
285          }
# Line 305 | Line 311 | public class ForkJoinTask8Test extends J
311              try {
312                  AsyncFib f = this;
313                  int n = f.number;
314 <                if (n > 1) {
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);
314 <                        r.fork();
315 <                    }
316 <                    f.number = n;
314 >                while (n > 1) {
315 >                    AsyncFib p = f;
316 >                    AsyncFib r = new AsyncFib(n - 2);
317 >                    f = new AsyncFib(--n);
318 >                    p.linkSubtasks(r, f);
319 >                    r.fork();
320                  }
321                  f.complete();
322              }
323              catch (Throwable ex) {
324                  compareAndSetForkJoinTaskTag(INITIAL_STATE, EXCEPTION_STATE);
325              }
326 +            if (getForkJoinTaskTag() == EXCEPTION_STATE)
327 +                throw new FJException();
328              return false;
329          }
330  
# Line 341 | Line 346 | public class ForkJoinTask8Test extends J
346          }
347  
348          public final boolean exec() {
349 <            FailingAsyncFib f = this;
350 <            int n = f.number;
351 <            if (n > 1) {
349 >            try {
350 >                FailingAsyncFib f = this;
351 >                int n = f.number;
352                  while (n > 1) {
353                      FailingAsyncFib p = f;
354                      FailingAsyncFib r = new FailingAsyncFib(n - 2);
# Line 351 | Line 356 | public class ForkJoinTask8Test extends J
356                      p.linkSubtasks(r, f);
357                      r.fork();
358                  }
359 <                f.number = n;
359 >                f.complete();
360              }
361 <            f.complete();
361 >            catch (Throwable ex) {
362 >                compareAndSetForkJoinTaskTag(INITIAL_STATE, EXCEPTION_STATE);
363 >            }
364 >            if (getForkJoinTaskTag() == EXCEPTION_STATE)
365 >                throw new FJException();
366              return false;
367          }
368  
# Line 913 | Line 922 | public class ForkJoinTask8Test extends J
922                  AsyncFib f = new AsyncFib(8);
923                  FailingAsyncFib g = new FailingAsyncFib(9);
924                  ForkJoinTask[] tasks = { f, g };
925 <                Collections.shuffle(Arrays.asList(tasks));
925 >                shuffle(tasks);
926                  try {
927                      invokeAll(tasks[0], tasks[1]);
928                      shouldThrow();
# Line 940 | Line 949 | public class ForkJoinTask8Test extends J
949                  FailingAsyncFib g = new FailingAsyncFib(9);
950                  AsyncFib h = new AsyncFib(7);
951                  ForkJoinTask[] tasks = { f, g, h };
952 <                Collections.shuffle(Arrays.asList(tasks));
952 >                shuffle(tasks);
953                  try {
954                      invokeAll(tasks[0], tasks[1], tasks[2]);
955                      shouldThrow();
# Line 967 | Line 976 | public class ForkJoinTask8Test extends J
976                  AsyncFib g = new AsyncFib(9);
977                  AsyncFib h = new AsyncFib(7);
978                  ForkJoinTask[] tasks = { f, g, h };
979 <                Collections.shuffle(Arrays.asList(tasks));
979 >                shuffle(tasks);
980                  try {
981                      invokeAll(Arrays.asList(tasks));
982                      shouldThrow();
# Line 1155 | Line 1164 | public class ForkJoinTask8Test extends J
1164      }
1165  
1166      // jdk9
1167 <    
1167 >
1168      /**
1169       * pollSubmission returns unexecuted submitted task, if present
1170       */
# Line 1165 | Line 1174 | public class ForkJoinTask8Test extends J
1174          final ForkJoinTask b = ForkJoinTask.adapt(awaiter(done));
1175          final ForkJoinTask c = ForkJoinTask.adapt(awaiter(done));
1176          final ForkJoinPool p = singletonPool();
1177 <        Thread external = new Thread() {
1178 <                public void run() {
1177 >        try (PoolCleaner cleaner = cleaner(p, done)) {
1178 >            Thread external = new Thread(new CheckedRunnable() {
1179 >                public void realRun() {
1180                      p.execute(a);
1181                      p.execute(b);
1182                      p.execute(c);
1183 <                }};
1184 <        RecursiveAction s = new CheckedRecursiveAction() {
1183 >                }});
1184 >            RecursiveAction s = new CheckedRecursiveAction() {
1185                  protected void realCompute() {
1186                      external.start();
1187                      try {
1188                          external.join();
1189 <                    } catch(Exception ex) {
1189 >                    } catch (Exception ex) {
1190                          threadUnexpectedException(ex);
1191                      }
1192                      assertTrue(p.hasQueuedSubmissions());
# Line 1185 | Line 1195 | public class ForkJoinTask8Test extends J
1195                      assertTrue(r == a || r == b || r == c);
1196                      assertFalse(r.isDone());
1197                  }};
1188 –        try {
1198              p.invoke(s);
1190 –        } finally {
1191 –            done.countDown();
1192 –            joinPool(p);
1199          }
1200      }
1201  
1196 –    
1202   }

Diff Legend

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