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

Comparing jsr166/src/test/tck/RecursiveTaskTest.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:45 2010 UTC

# Line 129 | Line 129 | public class RecursiveTaskTest extends J
129          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
130              public Integer compute() {
131                  FibTask f = new FibTask(8);
132 <                f.fork();
132 >                threadAssertSame(f, f.fork());
133                  Integer r = f.join();
134                  threadAssertTrue(r == 21);
135                  threadAssertTrue(f.isDone());
# Line 147 | Line 147 | public class RecursiveTaskTest extends J
147              public Integer compute() {
148                  try {
149                      FibTask f = new FibTask(8);
150 <                    f.fork();
150 >                    threadAssertSame(f, f.fork());
151                      Integer r = f.get();
152                      threadAssertTrue(r == 21);
153                      threadAssertTrue(f.isDone());
# Line 169 | Line 169 | public class RecursiveTaskTest extends J
169              public Integer compute() {
170                  try {
171                      FibTask f = new FibTask(8);
172 <                    f.fork();
172 >                    threadAssertSame(f, f.fork());
173                      Integer r = f.get(5L, TimeUnit.SECONDS);
174                      threadAssertTrue(r == 21);
175                      threadAssertTrue(f.isDone());
# Line 190 | Line 190 | public class RecursiveTaskTest extends J
190          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
191              public Integer compute() {
192                  FibTask f = new FibTask(8);
193 <                f.fork();
193 >                threadAssertSame(f, f.fork());
194                  f.quietlyJoin();
195                  Integer r = f.getRawResult();
196                  threadAssertTrue(r == 21);
# Line 210 | Line 210 | public class RecursiveTaskTest extends J
210          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
211              public Integer compute() {
212                  FibTask f = new FibTask(8);
213 <                f.fork();
213 >                threadAssertSame(f, f.fork());
214                  f.helpQuiesce();
215                  Integer r = f.getRawResult();
216                  threadAssertTrue(r == 21);
# Line 265 | Line 265 | public class RecursiveTaskTest extends J
265              public Integer compute() {
266                  try {
267                      FailingFibTask f = new FailingFibTask(8);
268 <                    f.fork();
268 >                    threadAssertSame(f, f.fork());
269                      Integer r = f.join();
270                      shouldThrow();
271                      return r;
# Line 285 | Line 285 | public class RecursiveTaskTest extends J
285              public Integer compute() {
286                  try {
287                      FailingFibTask f = new FailingFibTask(8);
288 <                    f.fork();
288 >                    threadAssertSame(f, f.fork());
289                      Integer r = f.get();
290                      shouldThrow();
291                      return r;
# Line 307 | Line 307 | public class RecursiveTaskTest extends J
307              public Integer compute() {
308                  try {
309                      FailingFibTask f = new FailingFibTask(8);
310 <                    f.fork();
310 >                    threadAssertSame(f, f.fork());
311                      Integer r = f.get(5L, TimeUnit.SECONDS);
312                      shouldThrow();
313                      return r;
# Line 328 | Line 328 | public class RecursiveTaskTest extends J
328          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
329              public Integer compute() {
330                  FailingFibTask f = new FailingFibTask(8);
331 <                f.fork();
331 >                threadAssertSame(f, f.fork());
332                  f.quietlyJoin();
333                  threadAssertTrue(f.isDone());
334                  threadAssertTrue(f.isCompletedAbnormally());
# Line 347 | Line 347 | public class RecursiveTaskTest extends J
347              public Integer compute() {
348                  try {
349                      FibTask f = new FibTask(8);
350 <                    f.cancel(true);
350 >                    threadAssertTrue(f.cancel(true));
351                      Integer r = f.invoke();
352                      shouldThrow();
353                      return r;
# Line 367 | Line 367 | public class RecursiveTaskTest extends J
367              public Integer compute() {
368                  try {
369                      FibTask f = new FibTask(8);
370 <                    f.cancel(true);
371 <                    f.fork();
370 >                    threadAssertTrue(f.cancel(true));
371 >                    threadAssertSame(f, f.fork());
372                      Integer r = f.join();
373                      shouldThrow();
374                      return r;
# Line 388 | Line 388 | public class RecursiveTaskTest extends J
388              public Integer compute() {
389                  try {
390                      FibTask f = new FibTask(8);
391 <                    f.cancel(true);
392 <                    f.fork();
391 >                    threadAssertTrue(f.cancel(true));
392 >                    threadAssertSame(f, f.fork());
393                      Integer r = f.get();
394                      shouldThrow();
395                      return r;
# Line 411 | Line 411 | public class RecursiveTaskTest extends J
411              public Integer compute() {
412                  try {
413                      FibTask f = new FibTask(8);
414 <                    f.cancel(true);
415 <                    f.fork();
414 >                    threadAssertTrue(f.cancel(true));
415 >                    threadAssertSame(f, f.fork());
416                      Integer r = f.get(5L, TimeUnit.SECONDS);
417                      shouldThrow();
418                      return r;
# Line 433 | Line 433 | public class RecursiveTaskTest extends J
433          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
434              public Integer compute() {
435                  FibTask f = new FibTask(8);
436 <                f.cancel(true);
437 <                f.fork();
436 >                threadAssertTrue(f.cancel(true));
437 >                threadAssertSame(f, f.fork());
438                  f.quietlyJoin();
439                  threadAssertTrue(f.isDone());
440                  threadAssertTrue(f.isCompletedAbnormally());
# Line 469 | Line 469 | public class RecursiveTaskTest extends J
469                  return NoResult;
470              }
471          };
472 <        a.invoke();
472 >        assertSame(NoResult, a.invoke());
473      }
474  
475      /**
# Line 495 | Line 495 | public class RecursiveTaskTest extends J
495                  return NoResult;
496              }
497          };
498 <        a.invoke();
498 >        assertSame(NoResult, a.invoke());
499      }
500  
501      /**
# Line 746 | Line 746 | public class RecursiveTaskTest extends J
746          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
747              public Integer compute() {
748                  FibTask g = new FibTask(9);
749 <                g.fork();
749 >                threadAssertSame(g, g.fork());
750                  FibTask f = new FibTask(8);
751 <                f.fork();
751 >                threadAssertSame(f, f.fork());
752                  threadAssertTrue(f.tryUnfork());
753                  helpQuiesce();
754                  threadAssertFalse(f.isDone());
# Line 767 | Line 767 | public class RecursiveTaskTest extends J
767          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
768              public Integer compute() {
769                  FibTask h = new FibTask(7);
770 <                h.fork();
770 >                threadAssertSame(h, h.fork());
771                  FibTask g = new FibTask(9);
772 <                g.fork();
772 >                threadAssertSame(g, g.fork());
773                  FibTask f = new FibTask(8);
774 <                f.fork();
774 >                threadAssertSame(f, f.fork());
775                  threadAssertTrue(getSurplusQueuedTaskCount() > 0);
776                  helpQuiesce();
777                  return NoResult;
# Line 787 | Line 787 | public class RecursiveTaskTest extends J
787          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
788              public Integer compute() {
789                  FibTask g = new FibTask(9);
790 <                g.fork();
790 >                threadAssertSame(g, g.fork());
791                  FibTask f = new FibTask(8);
792 <                f.fork();
792 >                threadAssertSame(f, f.fork());
793                  threadAssertTrue(peekNextLocalTask() == f);
794 <                f.join();
794 >                threadAssertTrue(f.join() == 21);
795                  threadAssertTrue(f.isDone());
796                  helpQuiesce();
797                  return NoResult;
# Line 808 | Line 808 | public class RecursiveTaskTest extends J
808          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
809              public Integer compute() {
810                  FibTask g = new FibTask(9);
811 <                g.fork();
811 >                threadAssertSame(g, g.fork());
812                  FibTask f = new FibTask(8);
813 <                f.fork();
813 >                threadAssertSame(f, f.fork());
814                  threadAssertTrue(pollNextLocalTask() == f);
815                  helpQuiesce();
816                  threadAssertFalse(f.isDone());
# Line 827 | Line 827 | public class RecursiveTaskTest extends J
827          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
828              public Integer compute() {
829                  FibTask g = new FibTask(9);
830 <                g.fork();
830 >                threadAssertSame(g, g.fork());
831                  FibTask f = new FibTask(8);
832 <                f.fork();
832 >                threadAssertSame(f, f.fork());
833                  threadAssertTrue(pollTask() == f);
834                  helpQuiesce();
835                  threadAssertFalse(f.isDone());
# Line 847 | Line 847 | public class RecursiveTaskTest extends J
847          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
848              public Integer compute() {
849                  FibTask g = new FibTask(9);
850 <                g.fork();
850 >                threadAssertSame(g, g.fork());
851                  FibTask f = new FibTask(8);
852 <                f.fork();
852 >                threadAssertSame(f, f.fork());
853                  threadAssertTrue(peekNextLocalTask() == g);
854 <                f.join();
854 >                threadAssertEquals(21, (int) f.join());
855                  helpQuiesce();
856                  threadAssertTrue(f.isDone());
857                  return NoResult;
# Line 868 | Line 868 | public class RecursiveTaskTest extends J
868          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
869              public Integer compute() {
870                  FibTask g = new FibTask(9);
871 <                g.fork();
871 >                threadAssertSame(g, g.fork());
872                  FibTask f = new FibTask(8);
873 <                f.fork();
873 >                threadAssertSame(f, f.fork());
874                  threadAssertTrue(pollNextLocalTask() == g);
875                  helpQuiesce();
876                  threadAssertTrue(f.isDone());
# Line 889 | Line 889 | public class RecursiveTaskTest extends J
889          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
890              public Integer compute() {
891                  FibTask g = new FibTask(9);
892 <                g.fork();
892 >                threadAssertSame(g, g.fork());
893                  FibTask f = new FibTask(8);
894 <                f.fork();
894 >                threadAssertSame(f, f.fork());
895                  threadAssertTrue(pollTask() == g);
896                  helpQuiesce();
897                  threadAssertTrue(f.isDone());

Diff Legend

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