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.17 by jsr166, Wed Sep 9 00:33:23 2015 UTC vs.
Revision 1.26 by jsr166, Wed Aug 10 01:28:14 2016 UTC

# Line 74 | Line 74 | public class ForkJoinTask8Test extends J
74      }
75  
76      private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
77 <        try {
77 >        try (PoolCleaner cleaner = cleaner(pool)) {
78              assertFalse(a.isDone());
79              assertFalse(a.isCompletedNormally());
80              assertFalse(a.isCompletedAbnormally());
# Line 90 | Line 90 | public class ForkJoinTask8Test extends J
90              assertFalse(a.isCancelled());
91              assertNull(a.getException());
92              assertNull(a.getRawResult());
93 –        } finally {
94 –            joinPool(pool);
93          }
94      }
95  
# Line 128 | Line 126 | public class ForkJoinTask8Test extends J
126  
127          {
128              Thread.currentThread().interrupt();
129 <            long t0 = System.nanoTime();
129 >            long startTime = System.nanoTime();
130              assertSame(expected, a.join());
131 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
131 >            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
132              Thread.interrupted();
133          }
134  
135          {
136              Thread.currentThread().interrupt();
137 <            long t0 = System.nanoTime();
137 >            long startTime = System.nanoTime();
138              a.quietlyJoin();        // should be no-op
139 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
139 >            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
140              Thread.interrupted();
141          }
142  
# Line 174 | Line 172 | public class ForkJoinTask8Test extends J
172          Thread.interrupted();
173  
174          {
175 <            long t0 = System.nanoTime();
175 >            long startTime = System.nanoTime();
176              a.quietlyJoin();        // should be no-op
177 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
177 >            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
178          }
179  
180          try {
# Line 200 | Line 198 | public class ForkJoinTask8Test extends J
198  
199      abstract static class BinaryAsyncAction extends ForkJoinTask<Void> {
200  
201 <        private BinaryAsyncAction parent;
201 >        private volatile BinaryAsyncAction parent;
202  
203 <        private BinaryAsyncAction sibling;
203 >        private volatile BinaryAsyncAction sibling;
204  
205          protected BinaryAsyncAction() {
206              setForkJoinTaskTag(INITIAL_STATE);
# Line 245 | Line 243 | public class ForkJoinTask8Test extends J
243              super.completeExceptionally(ex);
244          }
245  
246 +        public boolean cancel(boolean mayInterruptIfRunning) {
247 +            if (super.cancel(mayInterruptIfRunning)) {
248 +                completeExceptionally(new FJException());
249 +                return true;
250 +            }
251 +            return false;
252 +        }
253 +
254          public final void complete() {
255              BinaryAsyncAction a = this;
256              for (;;) {
# Line 267 | Line 273 | public class ForkJoinTask8Test extends J
273          }
274  
275          public final void completeExceptionally(Throwable ex) {
276 <            BinaryAsyncAction a = this;
271 <            while (!a.isCompletedAbnormally()) {
276 >            for (BinaryAsyncAction a = this;;) {
277                  a.completeThisExceptionally(ex);
278                  BinaryAsyncAction s = a.sibling;
279 <                if (s != null)
280 <                    s.cancel(false);
281 <                if (!a.onException() || (a = a.parent) == null)
279 >                if (s != null && !s.isDone())
280 >                    s.completeExceptionally(ex);
281 >                if ((a = a.parent) == null)
282                      break;
283              }
284          }
# Line 305 | Line 310 | public class ForkJoinTask8Test extends J
310              try {
311                  AsyncFib f = this;
312                  int n = f.number;
313 <                if (n > 1) {
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);
314 <                        r.fork();
315 <                    }
316 <                    f.number = n;
313 >                while (n > 1) {
314 >                    AsyncFib p = f;
315 >                    AsyncFib r = new AsyncFib(n - 2);
316 >                    f = new AsyncFib(--n);
317 >                    p.linkSubtasks(r, f);
318 >                    r.fork();
319                  }
320                  f.complete();
321              }
322              catch (Throwable ex) {
323                  compareAndSetForkJoinTaskTag(INITIAL_STATE, EXCEPTION_STATE);
324              }
325 +            if (getForkJoinTaskTag() == EXCEPTION_STATE)
326 +                throw new FJException();
327              return false;
328          }
329  
# Line 341 | Line 345 | public class ForkJoinTask8Test extends J
345          }
346  
347          public final boolean exec() {
348 <            FailingAsyncFib f = this;
349 <            int n = f.number;
350 <            if (n > 1) {
348 >            try {
349 >                FailingAsyncFib f = this;
350 >                int n = f.number;
351                  while (n > 1) {
352                      FailingAsyncFib p = f;
353                      FailingAsyncFib r = new FailingAsyncFib(n - 2);
# Line 351 | Line 355 | public class ForkJoinTask8Test extends J
355                      p.linkSubtasks(r, f);
356                      r.fork();
357                  }
358 <                f.number = n;
358 >                f.complete();
359 >            }
360 >            catch (Throwable ex) {
361 >                compareAndSetForkJoinTaskTag(INITIAL_STATE, EXCEPTION_STATE);
362              }
363 <            f.complete();
363 >            if (getForkJoinTaskTag() == EXCEPTION_STATE)
364 >                throw new FJException();
365              return false;
366          }
367  
# Line 913 | Line 921 | public class ForkJoinTask8Test extends J
921                  AsyncFib f = new AsyncFib(8);
922                  FailingAsyncFib g = new FailingAsyncFib(9);
923                  ForkJoinTask[] tasks = { f, g };
924 <                Collections.shuffle(Arrays.asList(tasks));
924 >                shuffle(tasks);
925                  try {
926                      invokeAll(tasks[0], tasks[1]);
927                      shouldThrow();
# Line 940 | Line 948 | public class ForkJoinTask8Test extends J
948                  FailingAsyncFib g = new FailingAsyncFib(9);
949                  AsyncFib h = new AsyncFib(7);
950                  ForkJoinTask[] tasks = { f, g, h };
951 <                Collections.shuffle(Arrays.asList(tasks));
951 >                shuffle(tasks);
952                  try {
953                      invokeAll(tasks[0], tasks[1], tasks[2]);
954                      shouldThrow();
# Line 967 | Line 975 | public class ForkJoinTask8Test extends J
975                  AsyncFib g = new AsyncFib(9);
976                  AsyncFib h = new AsyncFib(7);
977                  ForkJoinTask[] tasks = { f, g, h };
978 <                Collections.shuffle(Arrays.asList(tasks));
978 >                shuffle(tasks);
979                  try {
980                      invokeAll(Arrays.asList(tasks));
981                      shouldThrow();
# Line 1165 | Line 1173 | public class ForkJoinTask8Test extends J
1173          final ForkJoinTask b = ForkJoinTask.adapt(awaiter(done));
1174          final ForkJoinTask c = ForkJoinTask.adapt(awaiter(done));
1175          final ForkJoinPool p = singletonPool();
1176 <        Thread external = new Thread(new CheckedRunnable() {
1177 <            public void realRun() {
1178 <                p.execute(a);
1179 <                p.execute(b);
1180 <                p.execute(c);
1181 <            }});
1182 <        RecursiveAction s = new CheckedRecursiveAction() {
1183 <            protected void realCompute() {
1184 <                external.start();
1185 <                try {
1186 <                    external.join();
1187 <                } catch (Exception ex) {
1188 <                    threadUnexpectedException(ex);
1189 <                }
1190 <                assertTrue(p.hasQueuedSubmissions());
1191 <                assertTrue(Thread.currentThread() instanceof ForkJoinWorkerThread);
1192 <                ForkJoinTask r = ForkJoinTask.pollSubmission();
1193 <                assertTrue(r == a || r == b || r == c);
1194 <                assertFalse(r.isDone());
1195 <            }};
1196 <        try {
1176 >        try (PoolCleaner cleaner = cleaner(p, done)) {
1177 >            Thread external = new Thread(new CheckedRunnable() {
1178 >                public void realRun() {
1179 >                    p.execute(a);
1180 >                    p.execute(b);
1181 >                    p.execute(c);
1182 >                }});
1183 >            RecursiveAction s = new CheckedRecursiveAction() {
1184 >                protected void realCompute() {
1185 >                    external.start();
1186 >                    try {
1187 >                        external.join();
1188 >                    } catch (Exception ex) {
1189 >                        threadUnexpectedException(ex);
1190 >                    }
1191 >                    assertTrue(p.hasQueuedSubmissions());
1192 >                    assertTrue(Thread.currentThread() instanceof ForkJoinWorkerThread);
1193 >                    ForkJoinTask r = ForkJoinTask.pollSubmission();
1194 >                    assertTrue(r == a || r == b || r == c);
1195 >                    assertFalse(r.isDone());
1196 >                }};
1197              p.invoke(s);
1190 –        } finally {
1191 –            done.countDown();
1192 –            joinPool(p);
1198          }
1199      }
1200  

Diff Legend

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