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.33 by jsr166, Thu Dec 20 04:58:53 2012 UTC

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

Diff Legend

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