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.17 by dl, Tue Sep 14 10:24:07 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      /**
502 <     * The value set by setRawResult is returned by invoke
502 >     * The value set by setRawResult is returned by getRawResult
503       */
504      public void testSetRawResult() {
505          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
506              public Integer compute() {
507                  setRawResult(NoResult);
508 +                threadAssertSame(getRawResult(), NoResult);
509                  return NoResult;
510              }
511          };
512 <        assertSame(NoResult, a.invoke());
512 >        a.invoke();
513      }
514  
515      /**
# Line 746 | Line 747 | public class RecursiveTaskTest extends J
747          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
748              public Integer compute() {
749                  FibTask g = new FibTask(9);
750 <                g.fork();
750 >                threadAssertSame(g, g.fork());
751                  FibTask f = new FibTask(8);
752 <                f.fork();
752 >                threadAssertSame(f, f.fork());
753                  threadAssertTrue(f.tryUnfork());
754                  helpQuiesce();
755                  threadAssertFalse(f.isDone());
# Line 767 | Line 768 | public class RecursiveTaskTest extends J
768          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
769              public Integer compute() {
770                  FibTask h = new FibTask(7);
771 <                h.fork();
771 >                threadAssertSame(h, h.fork());
772                  FibTask g = new FibTask(9);
773 <                g.fork();
773 >                threadAssertSame(g, g.fork());
774                  FibTask f = new FibTask(8);
775 <                f.fork();
775 >                threadAssertSame(f, f.fork());
776                  threadAssertTrue(getSurplusQueuedTaskCount() > 0);
777                  helpQuiesce();
778                  return NoResult;
# Line 787 | Line 788 | public class RecursiveTaskTest extends J
788          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
789              public Integer compute() {
790                  FibTask g = new FibTask(9);
791 <                g.fork();
791 >                threadAssertSame(g, g.fork());
792                  FibTask f = new FibTask(8);
793 <                f.fork();
793 >                threadAssertSame(f, f.fork());
794                  threadAssertTrue(peekNextLocalTask() == f);
795 <                f.join();
795 >                threadAssertTrue(f.join() == 21);
796                  threadAssertTrue(f.isDone());
797                  helpQuiesce();
798                  return NoResult;
# Line 808 | Line 809 | public class RecursiveTaskTest extends J
809          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
810              public Integer compute() {
811                  FibTask g = new FibTask(9);
812 <                g.fork();
812 >                threadAssertSame(g, g.fork());
813                  FibTask f = new FibTask(8);
814 <                f.fork();
814 >                threadAssertSame(f, f.fork());
815                  threadAssertTrue(pollNextLocalTask() == f);
816                  helpQuiesce();
817                  threadAssertFalse(f.isDone());
# Line 827 | Line 828 | public class RecursiveTaskTest extends J
828          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
829              public Integer compute() {
830                  FibTask g = new FibTask(9);
831 <                g.fork();
831 >                threadAssertSame(g, g.fork());
832                  FibTask f = new FibTask(8);
833 <                f.fork();
833 >                threadAssertSame(f, f.fork());
834                  threadAssertTrue(pollTask() == f);
835                  helpQuiesce();
836                  threadAssertFalse(f.isDone());
# Line 847 | Line 848 | public class RecursiveTaskTest extends J
848          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
849              public Integer compute() {
850                  FibTask g = new FibTask(9);
851 <                g.fork();
851 >                threadAssertSame(g, g.fork());
852                  FibTask f = new FibTask(8);
853 <                f.fork();
853 >                threadAssertSame(f, f.fork());
854                  threadAssertTrue(peekNextLocalTask() == g);
855 <                f.join();
855 >                threadAssertEquals(21, (int) f.join());
856                  helpQuiesce();
857                  threadAssertTrue(f.isDone());
858                  return NoResult;
# Line 868 | Line 869 | public class RecursiveTaskTest extends J
869          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
870              public Integer compute() {
871                  FibTask g = new FibTask(9);
872 <                g.fork();
872 >                threadAssertSame(g, g.fork());
873                  FibTask f = new FibTask(8);
874 <                f.fork();
874 >                threadAssertSame(f, f.fork());
875                  threadAssertTrue(pollNextLocalTask() == g);
876                  helpQuiesce();
877                  threadAssertTrue(f.isDone());
# Line 889 | Line 890 | public class RecursiveTaskTest extends J
890          RecursiveTask<Integer> a = new RecursiveTask<Integer>() {
891              public Integer compute() {
892                  FibTask g = new FibTask(9);
893 <                g.fork();
893 >                threadAssertSame(g, g.fork());
894                  FibTask f = new FibTask(8);
895 <                f.fork();
895 >                threadAssertSame(f, f.fork());
896                  threadAssertTrue(pollTask() == g);
897                  helpQuiesce();
898                  threadAssertTrue(f.isDone());

Diff Legend

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