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.27 by jsr166, Tue Nov 23 08:48:23 2010 UTC vs.
Revision 1.29 by dl, Tue Feb 22 01:18:59 2011 UTC

# Line 134 | Line 134 | public class RecursiveActionTest extends
134          assertFalse(a.isCancelled());
135          assertFalse(a.isCompletedNormally());
136          assertTrue(a.isCompletedAbnormally());
137 <        assertSame(t, a.getException());
137 >        assertSame(t.getClass(), a.getException().getClass());
138          assertNull(a.getRawResult());
139          assertFalse(a.cancel(false));
140          assertFalse(a.cancel(true));
# Line 143 | Line 143 | public class RecursiveActionTest extends
143              a.join();
144              shouldThrow();
145          } catch (Throwable expected) {
146 <            assertSame(t, expected);
146 >            assertSame(expected.getClass(), t.getClass());
147          }
148  
149          try {
150              a.get();
151              shouldThrow();
152          } catch (ExecutionException success) {
153 <            assertSame(t, success.getCause());
153 >            assertSame(t.getClass(), success.getCause().getClass());
154          } catch (Throwable fail) { threadUnexpectedException(fail); }
155  
156          try {
157              a.get(5L, SECONDS);
158              shouldThrow();
159          } catch (ExecutionException success) {
160 <            assertSame(t, success.getCause());
160 >            assertSame(t.getClass(), success.getCause().getClass());
161          } catch (Throwable fail) { threadUnexpectedException(fail); }
162      }
163  
164 <    static final class FJException extends RuntimeException {
165 <        FJException() { super(); }
164 >    public static final class FJException extends RuntimeException {
165 >        public FJException() { super(); }
166 >        public FJException(Throwable cause) { super(cause); }
167      }
168  
169      // A simple recursive action for testing
# Line 255 | Line 256 | public class RecursiveActionTest extends
256          RecursiveAction a = new CheckedRecursiveAction() {
257              public void realCompute() {
258                  FibAction f = new FibAction(8);
259 +                final Thread myself = Thread.currentThread();
260  
261                  // test join()
262                  assertSame(f, f.fork());
263 <                Thread.currentThread().interrupt();
263 >                myself.interrupt();
264 >                assertTrue(myself.isInterrupted());
265                  assertNull(f.join());
266                  Thread.interrupted();
267                  assertEquals(21, f.result);
# Line 267 | Line 270 | public class RecursiveActionTest extends
270                  f.reinitialize();
271                  f.cancel(true);
272                  assertSame(f, f.fork());
273 <                Thread.currentThread().interrupt();
273 >                myself.interrupt();
274 >                assertTrue(myself.isInterrupted());
275                  try {
276                      f.join();
277                      shouldThrow();
# Line 279 | Line 283 | public class RecursiveActionTest extends
283                  f.reinitialize();
284                  f.completeExceptionally(new FJException());
285                  assertSame(f, f.fork());
286 <                Thread.currentThread().interrupt();
286 >                myself.interrupt();
287 >                assertTrue(myself.isInterrupted());
288                  try {
289                      f.join();
290                      shouldThrow();
# Line 291 | Line 296 | public class RecursiveActionTest extends
296                  // test quietlyJoin()
297                  f.reinitialize();
298                  assertSame(f, f.fork());
299 <                Thread.currentThread().interrupt();
299 >                myself.interrupt();
300 >                assertTrue(myself.isInterrupted());
301                  f.quietlyJoin();
302                  Thread.interrupted();
303                  assertEquals(21, f.result);
# Line 300 | Line 306 | public class RecursiveActionTest extends
306                  f.reinitialize();
307                  f.cancel(true);
308                  assertSame(f, f.fork());
309 <                Thread.currentThread().interrupt();
309 >                myself.interrupt();
310 >                assertTrue(myself.isInterrupted());
311                  f.quietlyJoin();
312                  Thread.interrupted();
313                  checkCancelled(f);
# Line 308 | Line 315 | public class RecursiveActionTest extends
315                  f.reinitialize();
316                  f.completeExceptionally(new FJException());
317                  assertSame(f, f.fork());
318 <                Thread.currentThread().interrupt();
318 >                myself.interrupt();
319 >                assertTrue(myself.isInterrupted());
320                  f.quietlyJoin();
321                  Thread.interrupted();
322                  checkCompletedAbnormally(f, f.getException());
# Line 348 | Line 356 | public class RecursiveActionTest extends
356              public void realRun() throws InterruptedException {
357                  FibAction[] fibActions = sq.take();
358                  FibAction f;
359 +                final Thread myself = Thread.currentThread();
360  
361                  // test join() ------------
362  
363                  f = fibActions[0];
364                  assertFalse(ForkJoinTask.inForkJoinPool());
365 <                Thread.currentThread().interrupt();
365 >                myself.interrupt();
366 >                assertTrue(myself.isInterrupted());
367                  assertNull(f.join());
368                  assertTrue(Thread.interrupted());
369                  assertEquals(21, f.result);
370                  checkCompletedNormally(f);
371  
372                  f = fibActions[1];
373 <                Thread.currentThread().interrupt();
373 >                myself.interrupt();
374 >                assertTrue(myself.isInterrupted());
375                  try {
376                      f.join();
377                      shouldThrow();
# Line 370 | Line 381 | public class RecursiveActionTest extends
381                  }
382  
383                  f = fibActions[2];
384 <                Thread.currentThread().interrupt();
384 >                myself.interrupt();
385 >                assertTrue(myself.isInterrupted());
386                  try {
387                      f.join();
388                      shouldThrow();
# Line 382 | Line 394 | public class RecursiveActionTest extends
394                  // test quietlyJoin() ---------
395  
396                  f = fibActions[3];
397 <                Thread.currentThread().interrupt();
397 >                myself.interrupt();
398 >                assertTrue(myself.isInterrupted());
399                  f.quietlyJoin();
400                  assertTrue(Thread.interrupted());
401                  assertEquals(21, f.result);
402                  checkCompletedNormally(f);
403  
404                  f = fibActions[4];
405 <                Thread.currentThread().interrupt();
405 >                myself.interrupt();
406 >                assertTrue(myself.isInterrupted());
407                  f.quietlyJoin();
408                  assertTrue(Thread.interrupted());
409                  checkCancelled(f);
410  
411                  f = fibActions[5];
412 <                Thread.currentThread().interrupt();
412 >                myself.interrupt();
413 >                assertTrue(myself.isInterrupted());
414                  f.quietlyJoin();
415                  assertTrue(Thread.interrupted());
416                  assertTrue(f.getException() instanceof FJException);
# Line 755 | Line 770 | public class RecursiveActionTest extends
770          RecursiveAction a = new CheckedRecursiveAction() {
771              public void realCompute() {
772                  ForkJoinWorkerThread w =
773 <                    (ForkJoinWorkerThread)(Thread.currentThread());
773 >                    (ForkJoinWorkerThread) Thread.currentThread();
774                  assertTrue(w.getPoolIndex() >= 0);
775 <                assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
775 >                // pool size can shrink after assigning index, so cannot check
776 >                // assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
777              }};
778          testInvokeOnPool(mainPool, a);
779      }

Diff Legend

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