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.15 by jsr166, Mon Sep 13 20:48:58 2010 UTC vs.
Revision 1.16 by jsr166, Mon Sep 13 23:23:44 2010 UTC

# Line 236 | Line 236 | public class ForkJoinTaskTest extends JS
236          RecursiveAction a = new RecursiveAction() {
237              public void compute() {
238                  AsyncFib f = new AsyncFib(8);
239 <                f.invoke();
239 >                threadAssertNull(f.invoke());
240                  threadAssertTrue(f.number == 21);
241                  threadAssertTrue(f.isDone());
242                  threadAssertFalse(f.isCancelled());
# Line 272 | Line 272 | public class ForkJoinTaskTest extends JS
272          RecursiveAction a = new RecursiveAction() {
273              public void compute() {
274                  AsyncFib f = new AsyncFib(8);
275 <                f.fork();
276 <                f.join();
275 >                threadAssertSame(f, f.fork());
276 >                threadAssertNull(f.join());
277                  threadAssertTrue(f.number == 21);
278                  threadAssertTrue(f.isDone());
279                  threadAssertTrue(f.getRawResult() == null);
# Line 289 | Line 289 | public class ForkJoinTaskTest extends JS
289              public void compute() {
290                  try {
291                      AsyncFib f = new AsyncFib(8);
292 <                    f.fork();
293 <                    f.get();
292 >                    threadAssertSame(f, f.fork());
293 >                    threadAssertNull(f.get());
294                      threadAssertTrue(f.number == 21);
295                      threadAssertTrue(f.isDone());
296                  } catch (Exception ex) {
# Line 308 | Line 308 | public class ForkJoinTaskTest extends JS
308              public void compute() {
309                  try {
310                      AsyncFib f = new AsyncFib(8);
311 <                    f.fork();
312 <                    f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
311 >                    threadAssertSame(f, f.fork());
312 >                    threadAssertNull(f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
313                      threadAssertTrue(f.number == 21);
314                      threadAssertTrue(f.isDone());
315                  } catch (Exception ex) {
# Line 327 | Line 327 | public class ForkJoinTaskTest extends JS
327              public void compute() {
328                  try {
329                      AsyncFib f = new AsyncFib(8);
330 <                    f.fork();
330 >                    threadAssertSame(f, f.fork());
331                      f.get(5L, null);
332                      shouldThrow();
333                  } catch (NullPointerException success) {
# Line 345 | Line 345 | public class ForkJoinTaskTest extends JS
345          RecursiveAction a = new RecursiveAction() {
346              public void compute() {
347                  AsyncFib f = new AsyncFib(8);
348 <                f.fork();
348 >                threadAssertSame(f, f.fork());
349                  f.quietlyJoin();
350                  threadAssertTrue(f.number == 21);
351                  threadAssertTrue(f.isDone());
# Line 362 | Line 362 | public class ForkJoinTaskTest extends JS
362          RecursiveAction a = new RecursiveAction() {
363              public void compute() {
364                  AsyncFib f = new AsyncFib(8);
365 <                f.fork();
365 >                threadAssertSame(f, f.fork());
366                  f.helpQuiesce();
367                  threadAssertTrue(f.number == 21);
368                  threadAssertTrue(f.isDone());
# Line 409 | Line 409 | public class ForkJoinTaskTest extends JS
409              public void compute() {
410                  try {
411                      FailingAsyncFib f = new FailingAsyncFib(8);
412 <                    f.fork();
412 >                    threadAssertSame(f, f.fork());
413                      f.join();
414                      shouldThrow();
415                  } catch (FJException success) {
# Line 426 | Line 426 | public class ForkJoinTaskTest extends JS
426              public void compute() {
427                  try {
428                      FailingAsyncFib f = new FailingAsyncFib(8);
429 <                    f.fork();
429 >                    threadAssertSame(f, f.fork());
430                      f.get();
431                      shouldThrow();
432                  } catch (ExecutionException success) {
# Line 445 | Line 445 | public class ForkJoinTaskTest extends JS
445              public void compute() {
446                  try {
447                      FailingAsyncFib f = new FailingAsyncFib(8);
448 <                    f.fork();
448 >                    threadAssertSame(f, f.fork());
449                      f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
450                      shouldThrow();
451                  } catch (ExecutionException success) {
# Line 463 | Line 463 | public class ForkJoinTaskTest extends JS
463          RecursiveAction a = new RecursiveAction() {
464              public void compute() {
465                  FailingAsyncFib f = new FailingAsyncFib(8);
466 <                f.fork();
466 >                threadAssertSame(f, f.fork());
467                  f.quietlyJoin();
468                  threadAssertTrue(f.isDone());
469                  threadAssertTrue(f.isCompletedAbnormally());
# Line 480 | Line 480 | public class ForkJoinTaskTest extends JS
480              public void compute() {
481                  try {
482                      AsyncFib f = new AsyncFib(8);
483 <                    f.cancel(true);
483 >                    threadAssertTrue(f.cancel(true));
484                      f.invoke();
485                      shouldThrow();
486                  } catch (CancellationException success) {
# Line 497 | Line 497 | public class ForkJoinTaskTest extends JS
497              public void compute() {
498                  try {
499                      AsyncFib f = new AsyncFib(8);
500 <                    f.cancel(true);
501 <                    f.fork();
500 >                    threadAssertTrue(f.cancel(true));
501 >                    threadAssertSame(f, f.fork());
502                      f.join();
503                      shouldThrow();
504                  } catch (CancellationException success) {
# Line 515 | Line 515 | public class ForkJoinTaskTest extends JS
515              public void compute() {
516                  try {
517                      AsyncFib f = new AsyncFib(8);
518 <                    f.cancel(true);
519 <                    f.fork();
518 >                    threadAssertTrue(f.cancel(true));
519 >                    threadAssertSame(f, f.fork());
520                      f.get();
521                      shouldThrow();
522                  } catch (CancellationException success) {
# Line 535 | Line 535 | public class ForkJoinTaskTest extends JS
535              public void compute() {
536                  try {
537                      AsyncFib f = new AsyncFib(8);
538 <                    f.cancel(true);
539 <                    f.fork();
538 >                    threadAssertTrue(f.cancel(true));
539 >                    threadAssertSame(f, f.fork());
540                      f.get(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
541                      shouldThrow();
542                  } catch (CancellationException success) {
# Line 554 | Line 554 | public class ForkJoinTaskTest extends JS
554          RecursiveAction a = new RecursiveAction() {
555              public void compute() {
556                  AsyncFib f = new AsyncFib(8);
557 <                f.cancel(true);
558 <                f.fork();
557 >                threadAssertTrue(f.cancel(true));
558 >                threadAssertSame(f, f.fork());
559                  f.quietlyJoin();
560                  threadAssertTrue(f.isDone());
561                  threadAssertTrue(f.isCompletedAbnormally());
# Line 584 | Line 584 | public class ForkJoinTaskTest extends JS
584              public void compute() {
585                  threadAssertTrue(getPool() == null);
586              }};
587 <        a.invoke();
587 >        assertNull(a.invoke());
588      }
589  
590      /**
# Line 606 | Line 606 | public class ForkJoinTaskTest extends JS
606              public void compute() {
607                  threadAssertTrue(!inForkJoinPool());
608              }};
609 <        a.invoke();
609 >        assertNull(a.invoke());
610      }
611  
612      /**
# Line 617 | Line 617 | public class ForkJoinTaskTest extends JS
617              public void compute() {
618                  setRawResult(null);
619              }};
620 <        a.invoke();
620 >        assertNull(a.invoke());
621      }
622  
623      /**
# Line 812 | Line 812 | public class ForkJoinTaskTest extends JS
812          RecursiveAction a = new RecursiveAction() {
813              public void compute() {
814                  AsyncFib g = new AsyncFib(9);
815 <                g.fork();
815 >                threadAssertSame(g, g.fork());
816                  AsyncFib f = new AsyncFib(8);
817 <                f.fork();
817 >                threadAssertSame(f, f.fork());
818                  threadAssertTrue(f.tryUnfork());
819                  helpQuiesce();
820                  threadAssertFalse(f.isDone());
# Line 831 | Line 831 | public class ForkJoinTaskTest extends JS
831          RecursiveAction a = new RecursiveAction() {
832              public void compute() {
833                  AsyncFib h = new AsyncFib(7);
834 <                h.fork();
834 >                threadAssertSame(h, h.fork());
835                  AsyncFib g = new AsyncFib(9);
836 <                g.fork();
836 >                threadAssertSame(g, g.fork());
837                  AsyncFib f = new AsyncFib(8);
838 <                f.fork();
838 >                threadAssertSame(f, f.fork());
839                  threadAssertTrue(getSurplusQueuedTaskCount() > 0);
840                  helpQuiesce();
841              }};
# Line 849 | Line 849 | public class ForkJoinTaskTest extends JS
849          RecursiveAction a = new RecursiveAction() {
850              public void compute() {
851                  AsyncFib g = new AsyncFib(9);
852 <                g.fork();
852 >                threadAssertSame(g, g.fork());
853                  AsyncFib f = new AsyncFib(8);
854 <                f.fork();
854 >                threadAssertSame(f, f.fork());
855                  threadAssertTrue(peekNextLocalTask() == f);
856 <                f.join();
856 >                threadAssertNull(f.join());
857                  threadAssertTrue(f.isDone());
858                  helpQuiesce();
859              }};
# Line 868 | Line 868 | public class ForkJoinTaskTest extends JS
868          RecursiveAction a = new RecursiveAction() {
869              public void compute() {
870                  AsyncFib g = new AsyncFib(9);
871 <                g.fork();
871 >                threadAssertSame(g, g.fork());
872                  AsyncFib f = new AsyncFib(8);
873 <                f.fork();
873 >                threadAssertSame(f, f.fork());
874                  threadAssertTrue(pollNextLocalTask() == f);
875                  helpQuiesce();
876                  threadAssertFalse(f.isDone());
# Line 886 | Line 886 | public class ForkJoinTaskTest extends JS
886          RecursiveAction a = new RecursiveAction() {
887              public void compute() {
888                  AsyncFib g = new AsyncFib(9);
889 <                g.fork();
889 >                threadAssertSame(g, g.fork());
890                  AsyncFib f = new AsyncFib(8);
891 <                f.fork();
891 >                threadAssertSame(f, f.fork());
892                  threadAssertTrue(pollTask() == f);
893                  helpQuiesce();
894                  threadAssertFalse(f.isDone());
# Line 904 | Line 904 | public class ForkJoinTaskTest extends JS
904          RecursiveAction a = new RecursiveAction() {
905              public void compute() {
906                  AsyncFib g = new AsyncFib(9);
907 <                g.fork();
907 >                threadAssertSame(g, g.fork());
908                  AsyncFib f = new AsyncFib(8);
909 <                f.fork();
909 >                threadAssertSame(f, f.fork());
910                  threadAssertTrue(peekNextLocalTask() == g);
911 <                f.join();
911 >                threadAssertNull(f.join());
912                  helpQuiesce();
913                  threadAssertTrue(f.isDone());
914              }};
# Line 923 | Line 923 | public class ForkJoinTaskTest extends JS
923          RecursiveAction a = new RecursiveAction() {
924              public void compute() {
925                  AsyncFib g = new AsyncFib(9);
926 <                g.fork();
926 >                threadAssertSame(g, g.fork());
927                  AsyncFib f = new AsyncFib(8);
928 <                f.fork();
928 >                threadAssertSame(f, f.fork());
929                  threadAssertTrue(pollNextLocalTask() == g);
930                  helpQuiesce();
931                  threadAssertTrue(f.isDone());
# Line 942 | Line 942 | public class ForkJoinTaskTest extends JS
942          RecursiveAction a = new RecursiveAction() {
943              public void compute() {
944                  AsyncFib g = new AsyncFib(9);
945 <                g.fork();
945 >                threadAssertSame(g, g.fork());
946                  AsyncFib f = new AsyncFib(8);
947 <                f.fork();
947 >                threadAssertSame(f, f.fork());
948                  threadAssertTrue(pollTask() == g);
949                  helpQuiesce();
950                  threadAssertTrue(f.isDone());

Diff Legend

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