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

Comparing jsr166/src/test/tck/RecursiveActionTest.java (file contents):
Revision 1.36 by jsr166, Sun Jun 26 06:50:19 2011 UTC vs.
Revision 1.50 by jsr166, Mon May 29 19:15:02 2017 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 < import junit.framework.*;
7 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
8 >
9 > import java.util.Arrays;
10 > import java.util.HashSet;
11   import java.util.concurrent.CancellationException;
9 – import java.util.concurrent.SynchronousQueue;
12   import java.util.concurrent.ExecutionException;
13   import java.util.concurrent.ForkJoinPool;
14   import java.util.concurrent.ForkJoinTask;
15   import java.util.concurrent.ForkJoinWorkerThread;
16   import java.util.concurrent.RecursiveAction;
17 + import java.util.concurrent.SynchronousQueue;
18   import java.util.concurrent.ThreadLocalRandom;
16 – import java.util.concurrent.TimeUnit;
19   import java.util.concurrent.TimeoutException;
20 < import static java.util.concurrent.TimeUnit.SECONDS;
21 < import java.util.Arrays;
22 < import java.util.HashSet;
20 >
21 > import junit.framework.Test;
22 > import junit.framework.TestSuite;
23  
24   public class RecursiveActionTest extends JSR166TestCase {
25  
26      public static void main(String[] args) {
27 <        junit.textui.TestRunner.run(suite());
27 >        main(suite(), args);
28      }
29  
30      public static Test suite() {
# Line 44 | Line 46 | public class RecursiveActionTest extends
46      }
47  
48      private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
49 <        try {
49 >        try (PoolCleaner cleaner = cleaner(pool)) {
50              checkNotDone(a);
51  
52              assertNull(pool.invoke(a));
53  
54              checkCompletedNormally(a);
53 –        } finally {
54 –            joinPool(pool);
55          }
56      }
57  
# Line 73 | Line 73 | public class RecursiveActionTest extends
73  
74              Thread.currentThread().interrupt();
75              try {
76 <                a.get(5L, SECONDS);
76 >                a.get(randomTimeout(), randomTimeUnit());
77                  shouldThrow();
78              } catch (InterruptedException success) {
79              } catch (Throwable fail) { threadUnexpectedException(fail); }
80          }
81  
82          try {
83 <            a.get(0L, SECONDS);
83 >            a.get(randomExpiredTimeout(), randomTimeUnit());
84              shouldThrow();
85          } catch (TimeoutException success) {
86          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 98 | Line 98 | public class RecursiveActionTest extends
98          assertFalse(a.cancel(true));
99          try {
100              assertNull(a.get());
101 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
102 <        try {
103 <            assertNull(a.get(5L, SECONDS));
101 >            assertNull(a.get(randomTimeout(), randomTimeUnit()));
102          } catch (Throwable fail) { threadUnexpectedException(fail); }
103      }
104  
# Line 125 | Line 123 | public class RecursiveActionTest extends
123          } catch (Throwable fail) { threadUnexpectedException(fail); }
124  
125          try {
126 <            a.get(5L, SECONDS);
126 >            a.get(randomTimeout(), randomTimeUnit());
127              shouldThrow();
128          } catch (CancellationException success) {
129          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 156 | Line 154 | public class RecursiveActionTest extends
154          } catch (Throwable fail) { threadUnexpectedException(fail); }
155  
156          try {
157 <            a.get(5L, SECONDS);
157 >            a.get(randomTimeout(), randomTimeUnit());
158              shouldThrow();
159          } catch (ExecutionException success) {
160              assertSame(t.getClass(), success.getCause().getClass());
# Line 168 | Line 166 | public class RecursiveActionTest extends
166          public FJException(Throwable cause) { super(cause); }
167      }
168  
169 <    // A simple recursive action for testing
169 >    /** A simple recursive action for testing. */
170      final class FibAction extends CheckedRecursiveAction {
171          final int number;
172          int result;
173          FibAction(int n) { number = n; }
174 <        public void realCompute() {
174 >        protected void realCompute() {
175              int n = number;
176              if (n <= 1)
177                  result = n;
# Line 186 | Line 184 | public class RecursiveActionTest extends
184          }
185      }
186  
187 <    // A recursive action failing in base case
187 >    /** A recursive action failing in base case. */
188      static final class FailingFibAction extends RecursiveAction {
189          final int number;
190          int result;
# Line 211 | Line 209 | public class RecursiveActionTest extends
209       */
210      public void testInvoke() {
211          RecursiveAction a = new CheckedRecursiveAction() {
212 <            public void realCompute() {
212 >            protected void realCompute() {
213                  FibAction f = new FibAction(8);
214                  assertNull(f.invoke());
215                  assertEquals(21, f.result);
# Line 227 | Line 225 | public class RecursiveActionTest extends
225       */
226      public void testQuietlyInvoke() {
227          RecursiveAction a = new CheckedRecursiveAction() {
228 <            public void realCompute() {
228 >            protected void realCompute() {
229                  FibAction f = new FibAction(8);
230                  f.quietlyInvoke();
231                  assertEquals(21, f.result);
# Line 241 | Line 239 | public class RecursiveActionTest extends
239       */
240      public void testForkJoin() {
241          RecursiveAction a = new CheckedRecursiveAction() {
242 <            public void realCompute() {
242 >            protected void realCompute() {
243                  FibAction f = new FibAction(8);
244                  assertSame(f, f.fork());
245                  assertNull(f.join());
# Line 256 | Line 254 | public class RecursiveActionTest extends
254       */
255      public void testJoinIgnoresInterrupts() {
256          RecursiveAction a = new CheckedRecursiveAction() {
257 <            public void realCompute() {
257 >            protected void realCompute() {
258                  FibAction f = new FibAction(8);
259 <                final Thread myself = Thread.currentThread();
259 >                final Thread currentThread = Thread.currentThread();
260  
261                  // test join()
262                  assertSame(f, f.fork());
263 <                myself.interrupt();
266 <                assertTrue(myself.isInterrupted());
263 >                currentThread.interrupt();
264                  assertNull(f.join());
265                  Thread.interrupted();
266                  assertEquals(21, f.result);
# Line 272 | Line 269 | public class RecursiveActionTest extends
269                  f = new FibAction(8);
270                  f.cancel(true);
271                  assertSame(f, f.fork());
272 <                myself.interrupt();
276 <                assertTrue(myself.isInterrupted());
272 >                currentThread.interrupt();
273                  try {
274                      f.join();
275                      shouldThrow();
# Line 285 | Line 281 | public class RecursiveActionTest extends
281                  f = new FibAction(8);
282                  f.completeExceptionally(new FJException());
283                  assertSame(f, f.fork());
284 <                myself.interrupt();
289 <                assertTrue(myself.isInterrupted());
284 >                currentThread.interrupt();
285                  try {
286                      f.join();
287                      shouldThrow();
# Line 298 | Line 293 | public class RecursiveActionTest extends
293                  // test quietlyJoin()
294                  f = new FibAction(8);
295                  assertSame(f, f.fork());
296 <                myself.interrupt();
302 <                assertTrue(myself.isInterrupted());
296 >                currentThread.interrupt();
297                  f.quietlyJoin();
298                  Thread.interrupted();
299                  assertEquals(21, f.result);
# Line 308 | Line 302 | public class RecursiveActionTest extends
302                  f = new FibAction(8);
303                  f.cancel(true);
304                  assertSame(f, f.fork());
305 <                myself.interrupt();
312 <                assertTrue(myself.isInterrupted());
305 >                currentThread.interrupt();
306                  f.quietlyJoin();
307                  Thread.interrupted();
308                  checkCancelled(f);
# Line 317 | Line 310 | public class RecursiveActionTest extends
310                  f = new FibAction(8);
311                  f.completeExceptionally(new FJException());
312                  assertSame(f, f.fork());
313 <                myself.interrupt();
321 <                assertTrue(myself.isInterrupted());
313 >                currentThread.interrupt();
314                  f.quietlyJoin();
315                  Thread.interrupted();
316                  checkCompletedAbnormally(f, f.getException());
# Line 336 | Line 328 | public class RecursiveActionTest extends
328          final SynchronousQueue<FibAction[]> sq =
329              new SynchronousQueue<FibAction[]>();
330          RecursiveAction a = new CheckedRecursiveAction() {
331 <            public void realCompute() throws InterruptedException {
331 >            protected void realCompute() throws InterruptedException {
332                  FibAction[] fibActions = new FibAction[6];
333                  for (int i = 0; i < fibActions.length; i++)
334                      fibActions[i] = new FibAction(8);
# Line 358 | Line 350 | public class RecursiveActionTest extends
350              public void realRun() throws InterruptedException {
351                  FibAction[] fibActions = sq.take();
352                  FibAction f;
353 <                final Thread myself = Thread.currentThread();
353 >                final Thread currentThread = Thread.currentThread();
354  
355                  // test join() ------------
356  
357                  f = fibActions[0];
358                  assertFalse(ForkJoinTask.inForkJoinPool());
359 <                myself.interrupt();
368 <                assertTrue(myself.isInterrupted());
359 >                currentThread.interrupt();
360                  assertNull(f.join());
361                  assertTrue(Thread.interrupted());
362                  assertEquals(21, f.result);
363                  checkCompletedNormally(f);
364  
365                  f = fibActions[1];
366 <                myself.interrupt();
376 <                assertTrue(myself.isInterrupted());
366 >                currentThread.interrupt();
367                  try {
368                      f.join();
369                      shouldThrow();
# Line 383 | Line 373 | public class RecursiveActionTest extends
373                  }
374  
375                  f = fibActions[2];
376 <                myself.interrupt();
387 <                assertTrue(myself.isInterrupted());
376 >                currentThread.interrupt();
377                  try {
378                      f.join();
379                      shouldThrow();
# Line 396 | Line 385 | public class RecursiveActionTest extends
385                  // test quietlyJoin() ---------
386  
387                  f = fibActions[3];
388 <                myself.interrupt();
400 <                assertTrue(myself.isInterrupted());
388 >                currentThread.interrupt();
389                  f.quietlyJoin();
390                  assertTrue(Thread.interrupted());
391                  assertEquals(21, f.result);
392                  checkCompletedNormally(f);
393  
394                  f = fibActions[4];
395 <                myself.interrupt();
408 <                assertTrue(myself.isInterrupted());
395 >                currentThread.interrupt();
396                  f.quietlyJoin();
397                  assertTrue(Thread.interrupted());
398                  checkCancelled(f);
399  
400                  f = fibActions[5];
401 <                myself.interrupt();
415 <                assertTrue(myself.isInterrupted());
401 >                currentThread.interrupt();
402                  f.quietlyJoin();
403                  assertTrue(Thread.interrupted());
404                  assertTrue(f.getException() instanceof FJException);
# Line 423 | Line 409 | public class RecursiveActionTest extends
409  
410          t = newStartedThread(r);
411          testInvokeOnPool(mainPool(), a);
412 <        awaitTermination(t, LONG_DELAY_MS);
412 >        awaitTermination(t);
413  
414          a.reinitialize();
415          t = newStartedThread(r);
416          testInvokeOnPool(singletonPool(), a);
417 <        awaitTermination(t, LONG_DELAY_MS);
417 >        awaitTermination(t);
418      }
419  
420      /**
# Line 436 | Line 422 | public class RecursiveActionTest extends
422       */
423      public void testForkGet() {
424          RecursiveAction a = new CheckedRecursiveAction() {
425 <            public void realCompute() throws Exception {
425 >            protected void realCompute() throws Exception {
426                  FibAction f = new FibAction(8);
427                  assertSame(f, f.fork());
428                  assertNull(f.get());
# Line 451 | Line 437 | public class RecursiveActionTest extends
437       */
438      public void testForkTimedGet() {
439          RecursiveAction a = new CheckedRecursiveAction() {
440 <            public void realCompute() throws Exception {
440 >            protected void realCompute() throws Exception {
441                  FibAction f = new FibAction(8);
442                  assertSame(f, f.fork());
443 <                assertNull(f.get(5L, SECONDS));
443 >                assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
444                  assertEquals(21, f.result);
445                  checkCompletedNormally(f);
446              }};
# Line 466 | Line 452 | public class RecursiveActionTest extends
452       */
453      public void testForkTimedGetNPE() {
454          RecursiveAction a = new CheckedRecursiveAction() {
455 <            public void realCompute() throws Exception {
455 >            protected void realCompute() throws Exception {
456                  FibAction f = new FibAction(8);
457                  assertSame(f, f.fork());
458                  try {
459 <                    f.get(5L, null);
459 >                    f.get(randomTimeout(), null);
460                      shouldThrow();
461                  } catch (NullPointerException success) {}
462              }};
# Line 482 | Line 468 | public class RecursiveActionTest extends
468       */
469      public void testForkQuietlyJoin() {
470          RecursiveAction a = new CheckedRecursiveAction() {
471 <            public void realCompute() {
471 >            protected void realCompute() {
472                  FibAction f = new FibAction(8);
473                  assertSame(f, f.fork());
474                  f.quietlyJoin();
# Line 498 | Line 484 | public class RecursiveActionTest extends
484       */
485      public void testForkHelpQuiesce() {
486          RecursiveAction a = new CheckedRecursiveAction() {
487 <            public void realCompute() {
487 >            protected void realCompute() {
488                  FibAction f = new FibAction(8);
489                  assertSame(f, f.fork());
490                  helpQuiesce();
491 +                while (!f.isDone()) // wait out race
492 +                    ;
493                  assertEquals(21, f.result);
494                  assertEquals(0, getQueuedTaskCount());
495                  checkCompletedNormally(f);
# Line 514 | Line 502 | public class RecursiveActionTest extends
502       */
503      public void testAbnormalInvoke() {
504          RecursiveAction a = new CheckedRecursiveAction() {
505 <            public void realCompute() {
505 >            protected void realCompute() {
506                  FailingFibAction f = new FailingFibAction(8);
507                  try {
508                      f.invoke();
# Line 531 | Line 519 | public class RecursiveActionTest extends
519       */
520      public void testAbnormalQuietlyInvoke() {
521          RecursiveAction a = new CheckedRecursiveAction() {
522 <            public void realCompute() {
522 >            protected void realCompute() {
523                  FailingFibAction f = new FailingFibAction(8);
524                  f.quietlyInvoke();
525                  assertTrue(f.getException() instanceof FJException);
# Line 545 | Line 533 | public class RecursiveActionTest extends
533       */
534      public void testAbnormalForkJoin() {
535          RecursiveAction a = new CheckedRecursiveAction() {
536 <            public void realCompute() {
536 >            protected void realCompute() {
537                  FailingFibAction f = new FailingFibAction(8);
538                  assertSame(f, f.fork());
539                  try {
# Line 563 | Line 551 | public class RecursiveActionTest extends
551       */
552      public void testAbnormalForkGet() {
553          RecursiveAction a = new CheckedRecursiveAction() {
554 <            public void realCompute() throws Exception {
554 >            protected void realCompute() throws Exception {
555                  FailingFibAction f = new FailingFibAction(8);
556                  assertSame(f, f.fork());
557                  try {
# Line 583 | Line 571 | public class RecursiveActionTest extends
571       */
572      public void testAbnormalForkTimedGet() {
573          RecursiveAction a = new CheckedRecursiveAction() {
574 <            public void realCompute() throws Exception {
574 >            protected void realCompute() throws Exception {
575                  FailingFibAction f = new FailingFibAction(8);
576                  assertSame(f, f.fork());
577                  try {
578 <                    f.get(5L, TimeUnit.SECONDS);
578 >                    f.get(LONG_DELAY_MS, MILLISECONDS);
579                      shouldThrow();
580                  } catch (ExecutionException success) {
581                      Throwable cause = success.getCause();
# Line 603 | Line 591 | public class RecursiveActionTest extends
591       */
592      public void testAbnormalForkQuietlyJoin() {
593          RecursiveAction a = new CheckedRecursiveAction() {
594 <            public void realCompute() {
594 >            protected void realCompute() {
595                  FailingFibAction f = new FailingFibAction(8);
596                  assertSame(f, f.fork());
597                  f.quietlyJoin();
# Line 618 | Line 606 | public class RecursiveActionTest extends
606       */
607      public void testCancelledInvoke() {
608          RecursiveAction a = new CheckedRecursiveAction() {
609 <            public void realCompute() {
609 >            protected void realCompute() {
610                  FibAction f = new FibAction(8);
611                  assertTrue(f.cancel(true));
612                  try {
# Line 636 | Line 624 | public class RecursiveActionTest extends
624       */
625      public void testCancelledForkJoin() {
626          RecursiveAction a = new CheckedRecursiveAction() {
627 <            public void realCompute() {
627 >            protected void realCompute() {
628                  FibAction f = new FibAction(8);
629                  assertTrue(f.cancel(true));
630                  assertSame(f, f.fork());
# Line 655 | Line 643 | public class RecursiveActionTest extends
643       */
644      public void testCancelledForkGet() {
645          RecursiveAction a = new CheckedRecursiveAction() {
646 <            public void realCompute() throws Exception {
646 >            protected void realCompute() throws Exception {
647                  FibAction f = new FibAction(8);
648                  assertTrue(f.cancel(true));
649                  assertSame(f, f.fork());
# Line 674 | Line 662 | public class RecursiveActionTest extends
662       */
663      public void testCancelledForkTimedGet() {
664          RecursiveAction a = new CheckedRecursiveAction() {
665 <            public void realCompute() throws Exception {
665 >            protected void realCompute() throws Exception {
666                  FibAction f = new FibAction(8);
667                  assertTrue(f.cancel(true));
668                  assertSame(f, f.fork());
669                  try {
670 <                    f.get(5L, SECONDS);
670 >                    f.get(LONG_DELAY_MS, MILLISECONDS);
671                      shouldThrow();
672                  } catch (CancellationException success) {
673                      checkCancelled(f);
# Line 693 | Line 681 | public class RecursiveActionTest extends
681       */
682      public void testCancelledForkQuietlyJoin() {
683          RecursiveAction a = new CheckedRecursiveAction() {
684 <            public void realCompute() {
684 >            protected void realCompute() {
685                  FibAction f = new FibAction(8);
686                  assertTrue(f.cancel(true));
687                  assertSame(f, f.fork());
# Line 709 | Line 697 | public class RecursiveActionTest extends
697      public void testGetPool() {
698          final ForkJoinPool mainPool = mainPool();
699          RecursiveAction a = new CheckedRecursiveAction() {
700 <            public void realCompute() {
700 >            protected void realCompute() {
701                  assertSame(mainPool, getPool());
702              }};
703          testInvokeOnPool(mainPool, a);
# Line 720 | Line 708 | public class RecursiveActionTest extends
708       */
709      public void testGetPool2() {
710          RecursiveAction a = new CheckedRecursiveAction() {
711 <            public void realCompute() {
711 >            protected void realCompute() {
712                  assertNull(getPool());
713              }};
714          assertNull(a.invoke());
# Line 731 | Line 719 | public class RecursiveActionTest extends
719       */
720      public void testInForkJoinPool() {
721          RecursiveAction a = new CheckedRecursiveAction() {
722 <            public void realCompute() {
722 >            protected void realCompute() {
723                  assertTrue(inForkJoinPool());
724              }};
725          testInvokeOnPool(mainPool(), a);
# Line 742 | Line 730 | public class RecursiveActionTest extends
730       */
731      public void testInForkJoinPool2() {
732          RecursiveAction a = new CheckedRecursiveAction() {
733 <            public void realCompute() {
733 >            protected void realCompute() {
734                  assertFalse(inForkJoinPool());
735              }};
736          assertNull(a.invoke());
# Line 754 | Line 742 | public class RecursiveActionTest extends
742      public void testWorkerGetPool() {
743          final ForkJoinPool mainPool = mainPool();
744          RecursiveAction a = new CheckedRecursiveAction() {
745 <            public void realCompute() {
745 >            protected void realCompute() {
746                  ForkJoinWorkerThread w =
747                      (ForkJoinWorkerThread) Thread.currentThread();
748                  assertSame(mainPool, w.getPool());
# Line 768 | Line 756 | public class RecursiveActionTest extends
756      public void testWorkerGetPoolIndex() {
757          final ForkJoinPool mainPool = mainPool();
758          RecursiveAction a = new CheckedRecursiveAction() {
759 <            public void realCompute() {
759 >            protected void realCompute() {
760                  ForkJoinWorkerThread w =
761                      (ForkJoinWorkerThread) Thread.currentThread();
762                  assertTrue(w.getPoolIndex() >= 0);
# Line 783 | Line 771 | public class RecursiveActionTest extends
771       */
772      public void testSetRawResult() {
773          RecursiveAction a = new CheckedRecursiveAction() {
774 <            public void realCompute() {
774 >            protected void realCompute() {
775                  setRawResult(null);
776                  assertNull(getRawResult());
777              }};
# Line 795 | Line 783 | public class RecursiveActionTest extends
783       */
784      public void testReinitialize() {
785          RecursiveAction a = new CheckedRecursiveAction() {
786 <            public void realCompute() {
786 >            protected void realCompute() {
787                  FibAction f = new FibAction(8);
788                  checkNotDone(f);
789  
# Line 815 | Line 803 | public class RecursiveActionTest extends
803       */
804      public void testReinitializeAbnormal() {
805          RecursiveAction a = new CheckedRecursiveAction() {
806 <            public void realCompute() {
806 >            protected void realCompute() {
807                  FailingFibAction f = new FailingFibAction(8);
808                  checkNotDone(f);
809  
# Line 838 | Line 826 | public class RecursiveActionTest extends
826       */
827      public void testCompleteExceptionally() {
828          RecursiveAction a = new CheckedRecursiveAction() {
829 <            public void realCompute() {
829 >            protected void realCompute() {
830                  FibAction f = new FibAction(8);
831                  f.completeExceptionally(new FJException());
832                  try {
# Line 856 | Line 844 | public class RecursiveActionTest extends
844       */
845      public void testComplete() {
846          RecursiveAction a = new CheckedRecursiveAction() {
847 <            public void realCompute() {
847 >            protected void realCompute() {
848                  FibAction f = new FibAction(8);
849                  f.complete(null);
850                  assertNull(f.invoke());
# Line 871 | Line 859 | public class RecursiveActionTest extends
859       */
860      public void testInvokeAll2() {
861          RecursiveAction a = new CheckedRecursiveAction() {
862 <            public void realCompute() {
862 >            protected void realCompute() {
863                  FibAction f = new FibAction(8);
864                  FibAction g = new FibAction(9);
865                  invokeAll(f, g);
# Line 888 | Line 876 | public class RecursiveActionTest extends
876       */
877      public void testInvokeAll1() {
878          RecursiveAction a = new CheckedRecursiveAction() {
879 <            public void realCompute() {
879 >            protected void realCompute() {
880                  FibAction f = new FibAction(8);
881                  invokeAll(f);
882                  checkCompletedNormally(f);
# Line 902 | Line 890 | public class RecursiveActionTest extends
890       */
891      public void testInvokeAll3() {
892          RecursiveAction a = new CheckedRecursiveAction() {
893 <            public void realCompute() {
893 >            protected void realCompute() {
894                  FibAction f = new FibAction(8);
895                  FibAction g = new FibAction(9);
896                  FibAction h = new FibAction(7);
# Line 925 | Line 913 | public class RecursiveActionTest extends
913       */
914      public void testInvokeAllCollection() {
915          RecursiveAction a = new CheckedRecursiveAction() {
916 <            public void realCompute() {
916 >            protected void realCompute() {
917                  FibAction f = new FibAction(8);
918                  FibAction g = new FibAction(9);
919                  FibAction h = new FibAction(7);
# Line 952 | Line 940 | public class RecursiveActionTest extends
940       */
941      public void testInvokeAllNPE() {
942          RecursiveAction a = new CheckedRecursiveAction() {
943 <            public void realCompute() {
943 >            protected void realCompute() {
944                  FibAction f = new FibAction(8);
945                  FibAction g = new FibAction(9);
946                  FibAction h = null;
# Line 969 | Line 957 | public class RecursiveActionTest extends
957       */
958      public void testAbnormalInvokeAll2() {
959          RecursiveAction a = new CheckedRecursiveAction() {
960 <            public void realCompute() {
960 >            protected void realCompute() {
961                  FibAction f = new FibAction(8);
962                  FailingFibAction g = new FailingFibAction(9);
963                  try {
# Line 987 | Line 975 | public class RecursiveActionTest extends
975       */
976      public void testAbnormalInvokeAll1() {
977          RecursiveAction a = new CheckedRecursiveAction() {
978 <            public void realCompute() {
978 >            protected void realCompute() {
979                  FailingFibAction g = new FailingFibAction(9);
980                  try {
981                      invokeAll(g);
# Line 1004 | Line 992 | public class RecursiveActionTest extends
992       */
993      public void testAbnormalInvokeAll3() {
994          RecursiveAction a = new CheckedRecursiveAction() {
995 <            public void realCompute() {
995 >            protected void realCompute() {
996                  FibAction f = new FibAction(8);
997                  FailingFibAction g = new FailingFibAction(9);
998                  FibAction h = new FibAction(7);
# Line 1023 | Line 1011 | public class RecursiveActionTest extends
1011       */
1012      public void testAbnormalInvokeAllCollection() {
1013          RecursiveAction a = new CheckedRecursiveAction() {
1014 <            public void realCompute() {
1014 >            protected void realCompute() {
1015                  FailingFibAction f = new FailingFibAction(8);
1016                  FibAction g = new FibAction(9);
1017                  FibAction h = new FibAction(7);
# Line 1047 | Line 1035 | public class RecursiveActionTest extends
1035       */
1036      public void testTryUnfork() {
1037          RecursiveAction a = new CheckedRecursiveAction() {
1038 <            public void realCompute() {
1038 >            protected void realCompute() {
1039                  FibAction g = new FibAction(9);
1040                  assertSame(g, g.fork());
1041                  FibAction f = new FibAction(8);
# Line 1066 | Line 1054 | public class RecursiveActionTest extends
1054       */
1055      public void testGetSurplusQueuedTaskCount() {
1056          RecursiveAction a = new CheckedRecursiveAction() {
1057 <            public void realCompute() {
1057 >            protected void realCompute() {
1058                  FibAction h = new FibAction(7);
1059                  assertSame(h, h.fork());
1060                  FibAction g = new FibAction(9);
# Line 1088 | Line 1076 | public class RecursiveActionTest extends
1076       */
1077      public void testPeekNextLocalTask() {
1078          RecursiveAction a = new CheckedRecursiveAction() {
1079 <            public void realCompute() {
1079 >            protected void realCompute() {
1080                  FibAction g = new FibAction(9);
1081                  assertSame(g, g.fork());
1082                  FibAction f = new FibAction(8);
# Line 1109 | Line 1097 | public class RecursiveActionTest extends
1097       */
1098      public void testPollNextLocalTask() {
1099          RecursiveAction a = new CheckedRecursiveAction() {
1100 <            public void realCompute() {
1100 >            protected void realCompute() {
1101                  FibAction g = new FibAction(9);
1102                  assertSame(g, g.fork());
1103                  FibAction f = new FibAction(8);
# Line 1127 | Line 1115 | public class RecursiveActionTest extends
1115       */
1116      public void testPollTask() {
1117          RecursiveAction a = new CheckedRecursiveAction() {
1118 <            public void realCompute() {
1118 >            protected void realCompute() {
1119                  FibAction g = new FibAction(9);
1120                  assertSame(g, g.fork());
1121                  FibAction f = new FibAction(8);
# Line 1145 | Line 1133 | public class RecursiveActionTest extends
1133       */
1134      public void testPeekNextLocalTaskAsync() {
1135          RecursiveAction a = new CheckedRecursiveAction() {
1136 <            public void realCompute() {
1136 >            protected void realCompute() {
1137                  FibAction g = new FibAction(9);
1138                  assertSame(g, g.fork());
1139                  FibAction f = new FibAction(8);
# Line 1165 | Line 1153 | public class RecursiveActionTest extends
1153       */
1154      public void testPollNextLocalTaskAsync() {
1155          RecursiveAction a = new CheckedRecursiveAction() {
1156 <            public void realCompute() {
1156 >            protected void realCompute() {
1157                  FibAction g = new FibAction(9);
1158                  assertSame(g, g.fork());
1159                  FibAction f = new FibAction(8);
# Line 1184 | Line 1172 | public class RecursiveActionTest extends
1172       */
1173      public void testPollTaskAsync() {
1174          RecursiveAction a = new CheckedRecursiveAction() {
1175 <            public void realCompute() {
1175 >            protected void realCompute() {
1176                  FibAction g = new FibAction(9);
1177                  assertSame(g, g.fork());
1178                  FibAction f = new FibAction(8);
# Line 1197 | Line 1185 | public class RecursiveActionTest extends
1185          testInvokeOnPool(asyncSingletonPool(), a);
1186      }
1187  
1188 +    /** Demo from RecursiveAction javadoc */
1189      static class SortTask extends RecursiveAction {
1190          final long[] array; final int lo, hi;
1191          SortTask(long[] array, int lo, int hi) {
1192              this.array = array; this.lo = lo; this.hi = hi;
1193          }
1194 <        final static int THRESHOLD = 100;
1194 >        SortTask(long[] array) { this(array, 0, array.length); }
1195          protected void compute() {
1196              if (hi - lo < THRESHOLD)
1197 <                sequentiallySort(array, lo, hi);
1197 >                sortSequentially(lo, hi);
1198              else {
1199                  int mid = (lo + hi) >>> 1;
1200                  invokeAll(new SortTask(array, lo, mid),
1201                            new SortTask(array, mid, hi));
1202 <                merge(array, lo, mid, hi);
1202 >                merge(lo, mid, hi);
1203              }
1204          }
1205 <        static void sequentiallySort(long[] array, int lo, int hi) {
1205 >        // implementation details follow:
1206 >        static final int THRESHOLD = 100;
1207 >        void sortSequentially(int lo, int hi) {
1208              Arrays.sort(array, lo, hi);
1209          }
1210 <        static void merge(long[] array, int lo, int mid, int hi) {
1210 >        void merge(int lo, int mid, int hi) {
1211              long[] buf = Arrays.copyOfRange(array, lo, mid);
1212              for (int i = 0, j = lo, k = mid; i < buf.length; j++)
1213                  array[j] = (k == hi || buf[i] < array[k]) ?
# Line 1233 | Line 1224 | public class RecursiveActionTest extends
1224          for (int i = 0; i < array.length; i++)
1225              array[i] = rnd.nextLong();
1226          long[] arrayClone = array.clone();
1227 <        testInvokeOnPool(mainPool(),
1237 <                         new SortTask(array, 0, array.length));
1227 >        testInvokeOnPool(mainPool(), new SortTask(array));
1228          Arrays.sort(arrayClone);
1229          assertTrue(Arrays.equals(array, arrayClone));
1230      }

Diff Legend

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