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.29 by jsr166, Mon Jun 20 04:31:59 2011 UTC vs.
Revision 1.32 by jsr166, Sun Dec 16 18:52:27 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 172 | Line 173 | public class FutureTaskTest extends JSR1
173                  }});
174              this.runCount = runCount;
175          }
176 <        public void done() {
176 >        @Override public void done() {
177              assertTrue(isDone());
178              doneCount.incrementAndGet();
179              super.done();
180          }
181 <        public boolean runAndReset() {
181 >        @Override public boolean runAndReset() {
182              runAndResetCount.incrementAndGet();
183              return super.runAndReset();
184          }
185 <        public void set(Object x) {
185 >        @Override public void set(Object x) {
186              setCount.incrementAndGet();
187              super.set(x);
188          }
189 <        public void setException(Throwable t) {
189 >        @Override public void setException(Throwable t) {
190              setExceptionCount.incrementAndGet();
191              super.setException(t);
192          }
# 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) interrupts a running task that subsequently
410 +     * succeeds, with a security manager that does not permit
411 +     * Thread.interrupt
412 +     */
413 +    public void testCancelInterrupt_ThrowsSecurityException() {
414 +        if (System.getSecurityManager() != null)
415 +            return;
416 +
417 +        final CountDownLatch pleaseCancel = new CountDownLatch(1);
418 +        final CountDownLatch cancelled = new CountDownLatch(1);
419 +        final PublicFutureTask task =
420 +            new PublicFutureTask(new CheckedRunnable() {
421 +                public void realRun() {
422 +                    pleaseCancel.countDown();
423 +                    await(cancelled);
424 +                    assertFalse(Thread.interrupted());
425 +                }});
426 +
427 +        final Thread t = newStartedThread(task);
428 +        await(pleaseCancel);
429 +        System.setSecurityManager(new SecurityManager() {
430 +            public void checkAccess(Thread t) { throw new SecurityException(); }
431 +            public void checkPermission(Permission p) {}});
432 +        try {
433 +            try {
434 +                task.cancel(true);
435 +                shouldThrow();
436 +            }
437 +            catch (SecurityException expected) {}
438 +        } finally {
439 +            System.setSecurityManager(null);
440 +        }
441 +        assertTrue(task.isCancelled());
442 +        assertTrue(task.isDone());
443 +        assertEquals(1, task.runCount());
444 +        assertEquals(1, task.doneCount());
445 +        assertEquals(0, task.setCount());
446 +        assertEquals(0, task.setExceptionCount());
447 +        cancelled.countDown();
448 +        awaitTermination(t);
449 +        assertEquals(1, task.setCount());
450 +        assertEquals(0, task.setExceptionCount());
451 +        tryToConfuseDoneTask(task);
452          checkCancelled(task);
453      }
454  

Diff Legend

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