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

Comparing jsr166/src/test/tck/FutureTaskTest.java (file contents):
Revision 1.30 by jsr166, Sat Dec 15 21:48:32 2012 UTC vs.
Revision 1.35 by jsr166, Mon Jan 14 21:54:42 2013 UTC

# Line 154 | Line 154 | public class FutureTaskTest extends JSR1
154          private PublicFutureTask(final Runnable runnable, Object result,
155                                   final AtomicInteger runCount) {
156              super(new Runnable() {
157 <                    public void run() {
158 <                        runCount.getAndIncrement();
159 <                        runnable.run();
160 <                    }}, result);
157 >                public void run() {
158 >                    runCount.getAndIncrement();
159 >                    runnable.run();
160 >                }}, result);
161              this.runCount = runCount;
162          }
163          PublicFutureTask(Callable callable) {
# Line 319 | Line 319 | public class FutureTaskTest extends JSR1
319          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
320          assertTrue(task.cancel(false));
321          task.run();
322 +        assertEquals(0, task.runCount());
323          assertEquals(0, task.setCount());
324          assertEquals(0, task.setExceptionCount());
325 +        assertTrue(task.isCancelled());
326 +        assertTrue(task.isDone());
327          tryToConfuseDoneTask(task);
325 –        checkCancelled(task);
328          assertEquals(0, task.runCount());
329 +        checkCancelled(task);
330      }
331  
332      /**
# Line 333 | Line 336 | public class FutureTaskTest extends JSR1
336          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
337          assertTrue(task.cancel(true));
338          task.run();
339 +        assertEquals(0, task.runCount());
340          assertEquals(0, task.setCount());
341          assertEquals(0, task.setExceptionCount());
342 +        assertTrue(task.isCancelled());
343 +        assertTrue(task.isDone());
344          tryToConfuseDoneTask(task);
339 –        checkCancelled(task);
345          assertEquals(0, task.runCount());
346 +        checkCancelled(task);
347      }
348  
349      /**
# Line 347 | Line 353 | public class FutureTaskTest extends JSR1
353          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
354          task.run();
355          assertFalse(task.cancel(false));
356 +        assertEquals(1, task.runCount());
357          assertEquals(1, task.setCount());
358          assertEquals(0, task.setExceptionCount());
359          tryToConfuseDoneTask(task);
# Line 361 | Line 368 | public class FutureTaskTest extends JSR1
368          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
369          task.run();
370          assertFalse(task.cancel(true));
371 +        assertEquals(1, task.runCount());
372          assertEquals(1, task.setCount());
373          assertEquals(0, task.setExceptionCount());
374          tryToConfuseDoneTask(task);
# Line 387 | Line 395 | public class FutureTaskTest extends JSR1
395          await(pleaseCancel);
396          assertTrue(task.cancel(true));
397          assertTrue(task.isCancelled());
398 +        assertTrue(task.isDone());
399          awaitTermination(t);
400          assertEquals(1, task.runCount());
401          assertEquals(1, task.setCount());
# Line 396 | Line 405 | public class FutureTaskTest extends JSR1
405      }
406  
407      /**
408 +     * cancel(true) tries to interrupt a running task, but
409 +     * Thread.interrupt throws (simulating a restrictive security
410 +     * manager)
411 +     */
412 +    public void testCancelInterrupt_ThrowsSecurityException() {
413 +        final CountDownLatch pleaseCancel = new CountDownLatch(1);
414 +        final CountDownLatch cancelled = new CountDownLatch(1);
415 +        final PublicFutureTask task =
416 +            new PublicFutureTask(new CheckedRunnable() {
417 +                public void realRun() {
418 +                    pleaseCancel.countDown();
419 +                    await(cancelled);
420 +                    assertFalse(Thread.interrupted());
421 +                }});
422 +
423 +        final Thread t = new Thread(task) {
424 +            // Simulate a restrictive security manager.
425 +            @Override public void interrupt() {
426 +                throw new SecurityException();
427 +            }};
428 +        t.setDaemon(true);
429 +        t.start();
430 +
431 +        await(pleaseCancel);
432 +        try {
433 +            task.cancel(true);
434 +            shouldThrow();
435 +        } catch (SecurityException expected) {}
436 +
437 +        // We failed to deliver the interrupt, but the world retains
438 +        // its sanity, as if we had done task.cancel(false)
439 +        assertTrue(task.isCancelled());
440 +        assertTrue(task.isDone());
441 +        assertEquals(1, task.runCount());
442 +        assertEquals(1, task.doneCount());
443 +        assertEquals(0, task.setCount());
444 +        assertEquals(0, task.setExceptionCount());
445 +        cancelled.countDown();
446 +        awaitTermination(t);
447 +        assertEquals(1, task.setCount());
448 +        assertEquals(0, task.setExceptionCount());
449 +        tryToConfuseDoneTask(task);
450 +        checkCancelled(task);
451 +    }
452 +
453 +    /**
454       * cancel(true) interrupts a running task that subsequently throws
455       */
456      public void testCancelInterrupt_taskFails() {
# Line 406 | Line 461 | public class FutureTaskTest extends JSR1
461                      try {
462                          pleaseCancel.countDown();
463                          delay(LONG_DELAY_MS);
464 <                    } finally { throw new RuntimeException(); }
464 >                        shouldThrow();
465 >                    } catch (Throwable t) {
466 >                        assertTrue(t instanceof InterruptedException);
467 >                    }
468 >                    throw new RuntimeException();
469                  }});
470  
471          Thread t = newStartedThread(task);

Diff Legend

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