70 PublicFutureTask pf = (PublicFutureTask) f;
71 assertEquals(1, pf.doneCount());
72 assertFalse(pf.runAndReset());
73 assertEquals(1, pf.doneCount());
74 Object r = null; Object exInfo = null;
75 try {
76 r = f.get();
77 } catch (CancellationException t) {
78 exInfo = CancellationException.class;
79 } catch (ExecutionException t) {
80 exInfo = t.getCause();
81 } catch (Throwable t) {
82 threadUnexpectedException(t);
83 }
84
85 // Check that run and runAndReset have no effect.
86 int savedRunCount = pf.runCount();
87 pf.run();
88 pf.runAndReset();
89 assertEquals(savedRunCount, pf.runCount());
90 try {
91 assertSame(r, f.get());
92 } catch (CancellationException t) {
93 assertSame(exInfo, CancellationException.class);
94 } catch (ExecutionException t) {
95 assertSame(exInfo, t.getCause());
96 } catch (Throwable t) {
97 threadUnexpectedException(t);
98 }
99 assertTrue(f.isDone());
100 }
101 }
102
103 void checkNotDone(Future<?> f) {
104 assertFalse(f.isDone());
105 assertFalse(f.isCancelled());
106 if (f instanceof PublicFutureTask) {
107 PublicFutureTask pf = (PublicFutureTask) f;
108 assertEquals(0, pf.doneCount());
109 assertEquals(0, pf.setCount());
110 assertEquals(0, pf.setExceptionCount());
111 }
112 }
113
114 void checkIsRunning(Future<?> f) {
115 checkNotDone(f);
116 if (f instanceof FutureTask) {
117 FutureTask ft = (FutureTask<?>) f;
118 // Check that run methods do nothing
119 ft.run();
120 if (f instanceof PublicFutureTask) {
121 PublicFutureTask pf = (PublicFutureTask) f;
122 int savedRunCount = pf.runCount();
123 pf.run();
124 assertFalse(pf.runAndReset());
125 assertEquals(savedRunCount, pf.runCount());
126 }
127 checkNotDone(f);
128 }
129 }
130
131 <T> void checkCompletedNormally(Future<T> f, T expected) {
132 checkIsDone(f);
133 assertFalse(f.isCancelled());
134
135 try {
136 assertSame(expected, f.get());
137 assertSame(expected, f.get(randomTimeout(), randomTimeUnit()));
138 } catch (Throwable fail) { threadUnexpectedException(fail); }
139 }
140
141 void checkCancelled(Future<?> f) {
142 checkIsDone(f);
143 assertTrue(f.isCancelled());
144
145 try {
146 f.get();
147 shouldThrow();
148 } catch (CancellationException success) {
149 } catch (Throwable fail) { threadUnexpectedException(fail); }
150
151 try {
152 f.get(randomTimeout(), randomTimeUnit());
153 shouldThrow();
154 } catch (CancellationException success) {
155 } catch (Throwable fail) { threadUnexpectedException(fail); }
156 }
157
158 void tryToConfuseDoneTask(PublicFutureTask pf) {
468 final PublicFutureTask task =
469 new PublicFutureTask(new CheckedRunnable() {
470 public void realRun() {
471 pleaseCancel.countDown();
472 await(cancelled);
473 assertFalse(Thread.interrupted());
474 }});
475
476 final Thread t = new Thread(task) {
477 // Simulate a restrictive security manager.
478 @Override public void interrupt() {
479 throw new SecurityException();
480 }};
481 t.setDaemon(true);
482 t.start();
483
484 await(pleaseCancel);
485 try {
486 task.cancel(true);
487 shouldThrow();
488 } catch (SecurityException expected) {}
489
490 // We failed to deliver the interrupt, but the world retains
491 // its sanity, as if we had done task.cancel(false)
492 assertTrue(task.isCancelled());
493 assertTrue(task.isDone());
494 assertEquals(1, task.runCount());
495 assertEquals(1, task.doneCount());
496 assertEquals(0, task.setCount());
497 assertEquals(0, task.setExceptionCount());
498 cancelled.countDown();
499 awaitTermination(t);
500 assertEquals(1, task.setCount());
501 assertEquals(0, task.setExceptionCount());
502 tryToConfuseDoneTask(task);
503 checkCancelled(task);
504 }
505
506 /**
507 * cancel(true) interrupts a running task that subsequently throws
508 */
|
70 PublicFutureTask pf = (PublicFutureTask) f;
71 assertEquals(1, pf.doneCount());
72 assertFalse(pf.runAndReset());
73 assertEquals(1, pf.doneCount());
74 Object r = null; Object exInfo = null;
75 try {
76 r = f.get();
77 } catch (CancellationException t) {
78 exInfo = CancellationException.class;
79 } catch (ExecutionException t) {
80 exInfo = t.getCause();
81 } catch (Throwable t) {
82 threadUnexpectedException(t);
83 }
84
85 // Check that run and runAndReset have no effect.
86 int savedRunCount = pf.runCount();
87 pf.run();
88 pf.runAndReset();
89 assertEquals(savedRunCount, pf.runCount());
90 Object r2 = null;
91 try {
92 r2 = f.get();
93 } catch (CancellationException t) {
94 assertSame(exInfo, CancellationException.class);
95 } catch (ExecutionException t) {
96 assertSame(exInfo, t.getCause());
97 } catch (Throwable t) {
98 threadUnexpectedException(t);
99 }
100 if (exInfo == null)
101 assertSame(r, r2);
102 assertTrue(f.isDone());
103 }
104 }
105
106 void checkNotDone(Future<?> f) {
107 assertFalse(f.isDone());
108 assertFalse(f.isCancelled());
109 if (f instanceof PublicFutureTask) {
110 PublicFutureTask pf = (PublicFutureTask) f;
111 assertEquals(0, pf.doneCount());
112 assertEquals(0, pf.setCount());
113 assertEquals(0, pf.setExceptionCount());
114 }
115 }
116
117 void checkIsRunning(Future<?> f) {
118 checkNotDone(f);
119 if (f instanceof FutureTask) {
120 FutureTask ft = (FutureTask<?>) f;
121 // Check that run methods do nothing
122 ft.run();
123 if (f instanceof PublicFutureTask) {
124 PublicFutureTask pf = (PublicFutureTask) f;
125 int savedRunCount = pf.runCount();
126 pf.run();
127 assertFalse(pf.runAndReset());
128 assertEquals(savedRunCount, pf.runCount());
129 }
130 checkNotDone(f);
131 }
132 }
133
134 <T> void checkCompletedNormally(Future<T> f, T expectedValue) {
135 checkIsDone(f);
136 assertFalse(f.isCancelled());
137
138 T v1 = null, v2 = null;
139 try {
140 v1 = f.get();
141 v2 = f.get(randomTimeout(), randomTimeUnit());
142 } catch (Throwable fail) { threadUnexpectedException(fail); }
143 assertSame(expectedValue, v1);
144 assertSame(expectedValue, v2);
145 }
146
147 void checkCancelled(Future<?> f) {
148 checkIsDone(f);
149 assertTrue(f.isCancelled());
150
151 try {
152 f.get();
153 shouldThrow();
154 } catch (CancellationException success) {
155 } catch (Throwable fail) { threadUnexpectedException(fail); }
156
157 try {
158 f.get(randomTimeout(), randomTimeUnit());
159 shouldThrow();
160 } catch (CancellationException success) {
161 } catch (Throwable fail) { threadUnexpectedException(fail); }
162 }
163
164 void tryToConfuseDoneTask(PublicFutureTask pf) {
474 final PublicFutureTask task =
475 new PublicFutureTask(new CheckedRunnable() {
476 public void realRun() {
477 pleaseCancel.countDown();
478 await(cancelled);
479 assertFalse(Thread.interrupted());
480 }});
481
482 final Thread t = new Thread(task) {
483 // Simulate a restrictive security manager.
484 @Override public void interrupt() {
485 throw new SecurityException();
486 }};
487 t.setDaemon(true);
488 t.start();
489
490 await(pleaseCancel);
491 try {
492 task.cancel(true);
493 shouldThrow();
494 } catch (SecurityException success) {}
495
496 // We failed to deliver the interrupt, but the world retains
497 // its sanity, as if we had done task.cancel(false)
498 assertTrue(task.isCancelled());
499 assertTrue(task.isDone());
500 assertEquals(1, task.runCount());
501 assertEquals(1, task.doneCount());
502 assertEquals(0, task.setCount());
503 assertEquals(0, task.setExceptionCount());
504 cancelled.countDown();
505 awaitTermination(t);
506 assertEquals(1, task.setCount());
507 assertEquals(0, task.setExceptionCount());
508 tryToConfuseDoneTask(task);
509 checkCancelled(task);
510 }
511
512 /**
513 * cancel(true) interrupts a running task that subsequently throws
514 */
|