[cvs] / jsr166 / src / test / tck / FutureTaskTest.java Repository:
ViewVC logotype

Annotation of /jsr166/src/test/tck/FutureTaskTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.3 - (view) (download)

1 : dl 1.1 /*
2 :     * Written by members of JCP JSR-166 Expert Group and released to the
3 :     * public domain. Use, modify, and redistribute this code in any way
4 :     * without acknowledgement. Other contributors include Andrew Wright,
5 :     * Jeffrey Hayes, Pat Fischer, Mike Judd.
6 :     */
7 :    
8 :     import junit.framework.*;
9 :     import java.util.concurrent.*;
10 :    
11 :     public class FutureTaskTest extends TestCase {
12 :    
13 :     public static void main(String[] args) {
14 :     junit.textui.TestRunner.run (suite());
15 :     }
16 :     public static Test suite() {
17 :     return new TestSuite(FutureTaskTest.class);
18 :     }
19 :    
20 :     private static long SHORT_DELAY_MS = 100;
21 :     private static long MEDIUM_DELAY_MS = 1000;
22 :     private static long LONG_DELAY_MS = 10000;
23 :    
24 : dl 1.3 public void testConstructor(){
25 :     try {
26 :     FutureTask task = new FutureTask(null);
27 :     fail("should throw");
28 :     }
29 :     catch(NullPointerException success) {
30 :     }
31 :     }
32 :    
33 :     public void testConstructor2(){
34 :     try {
35 :     FutureTask task = new FutureTask(null, Boolean.TRUE);
36 :     fail("should throw");
37 :     }
38 :     catch(NullPointerException success) {
39 :     }
40 :     }
41 :    
42 : dl 1.1 public void testIsDone(){
43 :     FutureTask task = new FutureTask( new Callable() {
44 :     public Object call() { return Boolean.TRUE; } });
45 :     task.run();
46 :     assertTrue(task.isDone());
47 :     assertFalse(task.isCancelled());
48 :     }
49 :    
50 :     public void testCancelBeforeRun() {
51 :     FutureTask task = new FutureTask( new Callable() {
52 :     public Object call() { return Boolean.TRUE; } });
53 :     assertTrue(task.cancel(false));
54 :     task.run();
55 :     assertTrue(task.isDone());
56 :     assertTrue(task.isCancelled());
57 :     }
58 :    
59 :     public void testCancelBeforeRun2() {
60 :     FutureTask task = new FutureTask( new Callable() {
61 :     public Object call() { return Boolean.TRUE; } });
62 :     assertTrue(task.cancel(true));
63 :     task.run();
64 :     assertTrue(task.isDone());
65 :     assertTrue(task.isCancelled());
66 :     }
67 :    
68 :     public void testCancelAfterRun() {
69 :     FutureTask task = new FutureTask( new Callable() {
70 :     public Object call() { return Boolean.TRUE; } });
71 :     task.run();
72 :     assertFalse(task.cancel(false));
73 :     assertTrue(task.isDone());
74 :     assertFalse(task.isCancelled());
75 :     }
76 :    
77 :     public void testCancelInterrupt(){
78 :     FutureTask task = new FutureTask( new Callable() {
79 :     public Object call() {
80 :     try {
81 :     Thread.sleep(SHORT_DELAY_MS* 2);
82 :     fail("should throw");
83 :     }
84 :     catch (InterruptedException success) {}
85 :     return Boolean.TRUE;
86 :     } });
87 :     Thread t = new Thread(task);
88 :     t.start();
89 :    
90 :     try{
91 :     Thread.sleep(SHORT_DELAY_MS);
92 :     assertTrue(task.cancel(true));
93 :     t.join();
94 :     assertTrue(task.isDone());
95 :     assertTrue(task.isCancelled());
96 :     } catch(InterruptedException e){
97 :     fail("unexpected exception");
98 :     }
99 :     }
100 :    
101 :    
102 :     public void testCancelNoInterrupt(){
103 :     FutureTask task = new FutureTask( new Callable() {
104 :     public Object call() {
105 :     try {
106 :     Thread.sleep(SHORT_DELAY_MS* 2);
107 :     }
108 :     catch (InterruptedException success) {
109 :     fail("should not interrupt");
110 :     }
111 :     return Boolean.TRUE;
112 :     } });
113 :     Thread t = new Thread(task);
114 :     t.start();
115 :    
116 :     try{
117 :     Thread.sleep(SHORT_DELAY_MS);
118 :     assertTrue(task.cancel(false));
119 :     t.join();
120 :     assertTrue(task.isDone());
121 :     assertTrue(task.isCancelled());
122 :     } catch(InterruptedException e){
123 :     fail("unexpected exception");
124 :     }
125 :     }
126 :    
127 :     public void testGet1() {
128 :     final FutureTask ft = new FutureTask(new Callable(){
129 :     public Object call(){
130 :     try{
131 :     Thread.sleep(MEDIUM_DELAY_MS);
132 : dl 1.2 } catch(InterruptedException e){
133 : dl 1.1 fail("unexpected exception");
134 :     }
135 :     return Boolean.TRUE;
136 :     }
137 :     });
138 :     Thread t = new Thread(new Runnable(){
139 :     public void run(){
140 :     try{
141 :     ft.get();
142 : dl 1.2 } catch(Exception e){
143 : dl 1.1 fail("unexpected exception");
144 :     }
145 :     }
146 :     });
147 :     try{
148 :     assertFalse(ft.isDone());
149 :     assertFalse(ft.isCancelled());
150 :     t.start();
151 :     Thread.sleep(SHORT_DELAY_MS);
152 :     ft.run();
153 :     t.join();
154 :     assertTrue(ft.isDone());
155 :     assertFalse(ft.isCancelled());
156 :     } catch(InterruptedException e){
157 :     fail("unexpected exception");
158 :    
159 :     }
160 :     }
161 :    
162 :     public void testTimedGet1() {
163 :     final FutureTask ft = new FutureTask(new Callable(){
164 :     public Object call(){
165 :     try{
166 :     Thread.sleep(MEDIUM_DELAY_MS);
167 : dl 1.2 } catch(InterruptedException e){
168 : dl 1.1 fail("unexpected exception");
169 :     }
170 :     return Boolean.TRUE;
171 :     }
172 :     });
173 :     Thread t = new Thread(new Runnable(){
174 :     public void run(){
175 :     try{
176 :     ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
177 :     } catch(TimeoutException success) {
178 :     } catch(Exception e){
179 :     fail("unexpected exception");
180 :     }
181 :     }
182 :     });
183 :     try{
184 :     assertFalse(ft.isDone());
185 :     assertFalse(ft.isCancelled());
186 :     t.start();
187 :     ft.run();
188 :     t.join();
189 :     assertTrue(ft.isDone());
190 :     assertFalse(ft.isCancelled());
191 :     } catch(InterruptedException e){
192 :     fail("unexpected exception");
193 :    
194 :     }
195 :     }
196 :    
197 :    
198 :     public void testGet_Cancellation(){
199 :     final FutureTask ft = new FutureTask(new Callable(){
200 :     public Object call(){
201 :     try{
202 :     Thread.sleep(MEDIUM_DELAY_MS);
203 : dl 1.2 } catch(InterruptedException e){
204 : dl 1.1 fail("unexpected exception");
205 :     }
206 :     return Boolean.TRUE;
207 :     }
208 :     });
209 :     try {
210 :     Thread.sleep(SHORT_DELAY_MS);
211 :     Thread t = new Thread(new Runnable(){
212 :     public void run(){
213 :     try{
214 :     ft.get();
215 :     fail("should throw");
216 : dl 1.2 } catch(CancellationException success){
217 : dl 1.1 }
218 :     catch(Exception e){
219 :     fail("unexpected exception");
220 :     }
221 :     }
222 :     });
223 :     t.start();
224 :     ft.cancel(true);
225 :     t.join();
226 : dl 1.2 } catch(InterruptedException success){
227 : dl 1.1 fail("unexpected exception");
228 :     }
229 :     }
230 :    
231 :     public void testGet_Cancellation2(){
232 :     final FutureTask ft = new FutureTask(new Callable(){
233 :     public Object call(){
234 :     try{
235 :     Thread.sleep(SHORT_DELAY_MS);
236 :     } catch(InterruptedException e) {
237 :     fail("unexpected exception");
238 :     }
239 :     return Boolean.TRUE;
240 :     }
241 :     });
242 :     try{
243 :     Thread.sleep(100);
244 :     Thread t = new Thread(new Runnable(){
245 :     public void run(){
246 :     try{
247 :     ft.get(3 * SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
248 :     fail("should throw");
249 : dl 1.2 } catch(CancellationException success) {}
250 : dl 1.1 catch(Exception e){
251 :     fail("unexpected exception");
252 :     }
253 :     }
254 :     });
255 :     t.start();
256 :     Thread.sleep(SHORT_DELAY_MS);
257 :     ft.cancel(true);
258 :     Thread.sleep(SHORT_DELAY_MS);
259 :     t.join();
260 : dl 1.2 } catch(InterruptedException ie){
261 : dl 1.1 fail("unexpected exception");
262 :     }
263 :     }
264 :    
265 :     public void testGet_ExecutionException(){
266 :     final FutureTask ft = new FutureTask(new Callable(){
267 :     public Object call(){
268 :     int i = 5/0;
269 :     return Boolean.TRUE;
270 :     }
271 :     });
272 :     try{
273 :     ft.run();
274 :     ft.get();
275 :     fail("should throw");
276 : dl 1.2 } catch(ExecutionException success){
277 : dl 1.1 }
278 :     catch(Exception e){
279 :     fail("unexpected exception");
280 :     }
281 :     }
282 :    
283 :     public void testTimedGet_ExecutionException2(){
284 :     final FutureTask ft = new FutureTask(new Callable(){
285 :     public Object call(){
286 :     int i = 5/0;
287 :     return Boolean.TRUE;
288 :     }
289 :     });
290 :     try{
291 :     ft.run();
292 :     ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
293 :     fail("should throw");
294 : dl 1.2 } catch(ExecutionException success) {
295 :     } catch(TimeoutException success) { } // unlikely but OK
296 : dl 1.1 catch(Exception e){
297 :     fail("unexpected exception");
298 :     }
299 :     }
300 :    
301 :    
302 :     public void testGet_InterruptedException(){
303 :     final FutureTask ft = new FutureTask(new Callable(){
304 :     public Object call(){
305 :     return new Object();
306 :     }
307 :     });
308 :     Thread t = new Thread(new Runnable(){
309 :     public void run(){
310 :     try{
311 :     ft.get();
312 :     fail("should throw");
313 :     } catch(InterruptedException success){
314 :     } catch(Exception e){
315 :     fail("unexpected exception");
316 :     }
317 :     }
318 :     });
319 :     try {
320 :     t.start();
321 :     Thread.sleep(SHORT_DELAY_MS);
322 :     t.interrupt();
323 :     t.join();
324 :     } catch(Exception e){
325 :     fail("unexpected exception");
326 :     }
327 :     }
328 :    
329 :     public void testTimedGet_InterruptedException2(){
330 :     final FutureTask ft = new FutureTask(new Callable(){
331 :     public Object call(){
332 :     return new Object();
333 :     }
334 :     });
335 :     Thread t = new Thread(new Runnable(){
336 :     public void run(){
337 :     try{
338 :     ft.get(100,TimeUnit.SECONDS);
339 :     fail("should throw");
340 : dl 1.2 } catch(InterruptedException success){}
341 : dl 1.1 catch(Exception e){
342 :     fail("unexpected exception");
343 :     }
344 :     }
345 :     });
346 :     try {
347 :     t.start();
348 :     Thread.sleep(SHORT_DELAY_MS);
349 :     t.interrupt();
350 :     t.join();
351 :     } catch(Exception e){
352 :     fail("unexpected exception");
353 :     }
354 :     }
355 :    
356 :     public void testGet_TimeoutException(){
357 :     FutureTask ft = new FutureTask(new Callable(){
358 :     public Object call(){
359 :     return new Object();
360 :     }
361 :     });
362 :     try{
363 :     ft.get(1,TimeUnit.MILLISECONDS);
364 :     fail("should throw");
365 : dl 1.2 } catch(TimeoutException success){}
366 :     catch(Exception success){
367 : dl 1.1 fail("unexpected exception");
368 :     }
369 :    
370 :    
371 :     }
372 :    
373 :     }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8