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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.4, Sun Sep 14 20:42:40 2003 UTC revision 1.5, Sat Sep 20 18:20:07 2003 UTC
# Line 30  Line 30 
30          public void setException(Throwable t) { super.setException(t); }          public void setException(Throwable t) { super.setException(t); }
31      }      }
32    
33        /**
34         *
35         */
36      public void testConstructor(){      public void testConstructor(){
37          try {          try {
38              FutureTask task = new FutureTask(null);              FutureTask task = new FutureTask(null);
39              fail("should throw");              shouldThrow();
40          }          }
41          catch(NullPointerException success) {          catch(NullPointerException success) {
42          }          }
43      }      }
44    
45        /**
46         *
47         */
48      public void testConstructor2(){      public void testConstructor2(){
49          try {          try {
50              FutureTask task = new FutureTask(null, Boolean.TRUE);              FutureTask task = new FutureTask(null, Boolean.TRUE);
51              fail("should throw");              shouldThrow();
52          }          }
53          catch(NullPointerException success) {          catch(NullPointerException success) {
54          }          }
55      }      }
56    
57        /**
58         *
59         */
60      public void testIsDone(){      public void testIsDone(){
61          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
62          task.run();          task.run();
# Line 55  Line 64 
64          assertFalse(task.isCancelled());          assertFalse(task.isCancelled());
65      }      }
66    
67        /**
68         *
69         */
70      public void testReset(){      public void testReset(){
71          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
72          task.run();          task.run();
# Line 62  Line 74 
74          assertTrue(task.reset());          assertTrue(task.reset());
75      }      }
76    
77        /**
78         *
79         */
80      public void testResetAfterCancel() {      public void testResetAfterCancel() {
81          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
82          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
# Line 71  Line 86 
86          assertFalse(task.reset());          assertFalse(task.reset());
87      }      }
88    
89        /**
90         *
91         */
92      public void testSetDone() {      public void testSetDone() {
93          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
94          task.setDone();          task.setDone();
# Line 78  Line 96 
96          assertFalse(task.isCancelled());          assertFalse(task.isCancelled());
97      }      }
98    
99        /**
100         *
101         */
102      public void testSetCancelled() {      public void testSetCancelled() {
103          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
104          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
# Line 86  Line 107 
107          assertTrue(task.isCancelled());          assertTrue(task.isCancelled());
108      }      }
109    
110        /**
111         *
112         */
113      public void testSet() {      public void testSet() {
114          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
115          task.set(one);          task.set(one);
# Line 93  Line 117 
117              assertEquals(task.get(), one);              assertEquals(task.get(), one);
118          }          }
119          catch(Exception e) {          catch(Exception e) {
120              fail("unexpected exception");              unexpectedException();
121          }          }
122      }      }
123    
124        /**
125         *
126         */
127      public void testSetException() {      public void testSetException() {
128          Exception nse = new NoSuchElementException();          Exception nse = new NoSuchElementException();
129          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
130          task.setException(nse);          task.setException(nse);
131          try {          try {
132              Object x = task.get();              Object x = task.get();
133              fail("should throw");              shouldThrow();
134          }          }
135          catch(ExecutionException ee) {          catch(ExecutionException ee) {
136              Throwable cause = ee.getCause();              Throwable cause = ee.getCause();
137              assertEquals(cause, nse);              assertEquals(cause, nse);
138          }          }
139          catch(Exception e) {          catch(Exception e) {
140              fail("unexpected exception");              unexpectedException();
141          }          }
142      }      }
143    
144        /**
145         *
146         */
147      public void testCancelBeforeRun() {      public void testCancelBeforeRun() {
148          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
149          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
# Line 122  Line 152 
152          assertTrue(task.isCancelled());          assertTrue(task.isCancelled());
153      }      }
154    
155        /**
156         *
157         */
158      public void testCancelBeforeRun2() {      public void testCancelBeforeRun2() {
159          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
160          assertTrue(task.cancel(true));          assertTrue(task.cancel(true));
# Line 130  Line 163 
163          assertTrue(task.isCancelled());          assertTrue(task.isCancelled());
164      }      }
165    
166        /**
167         *
168         */
169      public void testCancelAfterRun() {      public void testCancelAfterRun() {
170          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
171          task.run();          task.run();
# Line 138  Line 174 
174          assertFalse(task.isCancelled());          assertFalse(task.isCancelled());
175      }      }
176    
177        /**
178         *
179         */
180      public void testCancelInterrupt(){      public void testCancelInterrupt(){
181          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new Callable() {
182                  public Object call() {                  public Object call() {
183                      try {                      try {
184                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
185                          threadFail("should throw");                          threadShouldThrow();
186                      }                      }
187                      catch (InterruptedException success) {}                      catch (InterruptedException success) {}
188                      return Boolean.TRUE;                      return Boolean.TRUE;
# Line 158  Line 197 
197              assertTrue(task.isDone());              assertTrue(task.isDone());
198              assertTrue(task.isCancelled());              assertTrue(task.isCancelled());
199          } catch(InterruptedException e){          } catch(InterruptedException e){
200              fail("unexpected exception");              unexpectedException();
201          }          }
202      }      }
203    
204    
205        /**
206         *
207         */
208      public void testCancelNoInterrupt(){      public void testCancelNoInterrupt(){
209          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new Callable() {
210                  public Object call() {                  public Object call() {
# Line 184  Line 226 
226              assertTrue(task.isDone());              assertTrue(task.isDone());
227              assertTrue(task.isCancelled());              assertTrue(task.isCancelled());
228          } catch(InterruptedException e){          } catch(InterruptedException e){
229              fail("unexpected exception");              unexpectedException();
230          }          }
231      }      }
232    
233        /**
234         *
235         */
236      public void testGet1() {      public void testGet1() {
237          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
238                  public Object call(){                  public Object call(){
239                      try{                      try{
240                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
241                      } catch(InterruptedException e){                      } catch(InterruptedException e){
242                          threadFail("unexpected exception");                          threadUnexpectedException();
243                      }                      }
244                      return Boolean.TRUE;                      return Boolean.TRUE;
245                  }                  }
# Line 204  Line 249 
249                      try{                      try{
250                          ft.get();                          ft.get();
251                      } catch(Exception e){                      } catch(Exception e){
252                          threadFail("unexpected exception");                          threadUnexpectedException();
253                      }                      }
254                  }                  }
255              });              });
# Line 218  Line 263 
263              assertTrue(ft.isDone());              assertTrue(ft.isDone());
264              assertFalse(ft.isCancelled());              assertFalse(ft.isCancelled());
265          } catch(InterruptedException e){          } catch(InterruptedException e){
266              fail("unexpected exception");              unexpectedException();
267    
268          }          }
269      }      }
270    
271        /**
272         *
273         */
274      public void testTimedGet1() {      public void testTimedGet1() {
275          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
276                  public Object call(){                  public Object call(){
277                      try{                      try{
278                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
279                      } catch(InterruptedException e){                      } catch(InterruptedException e){
280                          threadFail("unexpected exception");                          threadUnexpectedException();
281                      }                      }
282                      return Boolean.TRUE;                      return Boolean.TRUE;
283                  }                  }
# Line 240  Line 288 
288                          ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);                          ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
289                      } catch(TimeoutException success) {                      } catch(TimeoutException success) {
290                      } catch(Exception e){                      } catch(Exception e){
291                          threadFail("unexpected exception");                          threadUnexpectedException();
292                      }                      }
293                  }                  }
294              });              });
# Line 253  Line 301 
301              assertTrue(ft.isDone());              assertTrue(ft.isDone());
302              assertFalse(ft.isCancelled());              assertFalse(ft.isCancelled());
303          } catch(InterruptedException e){          } catch(InterruptedException e){
304              fail("unexpected exception");              unexpectedException();
305    
306          }          }
307      }      }
308    
309    
310        /**
311         *
312         */
313      public void testGet_Cancellation(){      public void testGet_Cancellation(){
314          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
315                  public Object call(){                  public Object call(){
316                      try{                      try{
317                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
318                      } catch(InterruptedException e){                      } catch(InterruptedException e){
319                          threadFail("unexpected exception");                          threadUnexpectedException();
320                      }                      }
321                      return Boolean.TRUE;                      return Boolean.TRUE;
322                  }                  }
# Line 276  Line 327 
327                      public void run(){                      public void run(){
328                          try{                          try{
329                              ft.get();                              ft.get();
330                              threadFail("should throw");                              threadShouldThrow();
331                          } catch(CancellationException success){                          } catch(CancellationException success){
332                          }                          }
333                          catch(Exception e){                          catch(Exception e){
334                              threadFail("unexpected exception");                              threadUnexpectedException();
335                          }                          }
336                      }                      }
337                  });                  });
# Line 288  Line 339 
339              ft.cancel(true);              ft.cancel(true);
340              t.join();              t.join();
341          } catch(InterruptedException success){          } catch(InterruptedException success){
342              fail("unexpected exception");              unexpectedException();
343          }          }
344      }      }
345    
346        /**
347         *
348         */
349      public void testGet_Cancellation2(){      public void testGet_Cancellation2(){
350          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
351                  public Object call(){                  public Object call(){
352                      try{                      try{
353                          Thread.sleep(SHORT_DELAY_MS);                          Thread.sleep(SHORT_DELAY_MS);
354                      } catch(InterruptedException e) {                      } catch(InterruptedException e) {
355                          threadFail("unexpected exception");                          threadUnexpectedException();
356                      }                      }
357                      return Boolean.TRUE;                      return Boolean.TRUE;
358                  }                  }
# Line 309  Line 363 
363                      public void run(){                      public void run(){
364                          try{                          try{
365                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
366                              threadFail("should throw");                              threadShouldThrow();
367                          } catch(CancellationException success) {}                          } catch(CancellationException success) {}
368                          catch(Exception e){                          catch(Exception e){
369                              threadFail("unexpected exception");                              threadUnexpectedException();
370                          }                          }
371                      }                      }
372                  });                  });
# Line 322  Line 376 
376              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
377              t.join();              t.join();
378          } catch(InterruptedException ie){          } catch(InterruptedException ie){
379              fail("unexpected exception");              unexpectedException();
380          }          }
381      }      }
382    
383        /**
384         *
385         */
386      public void testGet_ExecutionException(){      public void testGet_ExecutionException(){
387          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
388                  public Object call(){                  public Object call(){
# Line 336  Line 393 
393          try{          try{
394              ft.run();              ft.run();
395              ft.get();              ft.get();
396              fail("should throw");              shouldThrow();
397          } catch(ExecutionException success){          } catch(ExecutionException success){
398          }          }
399          catch(Exception e){          catch(Exception e){
400              fail("unexpected exception");              unexpectedException();
401          }          }
402      }      }
403    
404        /**
405         *
406         */
407      public void testTimedGet_ExecutionException2(){      public void testTimedGet_ExecutionException2(){
408          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
409                  public Object call(){                  public Object call(){
# Line 354  Line 414 
414          try{          try{
415              ft.run();              ft.run();
416              ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);              ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
417              fail("should throw");              shouldThrow();
418          } catch(ExecutionException success) {          } catch(ExecutionException success) {
419          } catch(TimeoutException success) { } // unlikely but OK          } catch(TimeoutException success) { } // unlikely but OK
420          catch(Exception e){          catch(Exception e){
421              fail("unexpected exception");              unexpectedException();
422          }          }
423      }      }
424    
425    
426        /**
427         *
428         */
429      public void testGet_InterruptedException(){      public void testGet_InterruptedException(){
430          final FutureTask ft = new FutureTask(new NoOpCallable());          final FutureTask ft = new FutureTask(new NoOpCallable());
431          Thread t = new Thread(new Runnable(){          Thread t = new Thread(new Runnable(){
432                  public void run(){                  public void run(){
433                      try{                      try{
434                          ft.get();                          ft.get();
435                          threadFail("should throw");                          threadShouldThrow();
436                      } catch(InterruptedException success){                      } catch(InterruptedException success){
437                      } catch(Exception e){                      } catch(Exception e){
438                          threadFail("unexpected exception");                          threadUnexpectedException();
439                      }                      }
440                  }                  }
441              });              });
# Line 382  Line 445 
445              t.interrupt();              t.interrupt();
446              t.join();              t.join();
447          } catch(Exception e){          } catch(Exception e){
448              fail("unexpected exception");              unexpectedException();
449          }          }
450      }      }
451    
452        /**
453         *
454         */
455      public void testTimedGet_InterruptedException2(){      public void testTimedGet_InterruptedException2(){
456          final FutureTask ft = new FutureTask(new NoOpCallable());          final FutureTask ft = new FutureTask(new NoOpCallable());
457          Thread t = new Thread(new Runnable(){          Thread t = new Thread(new Runnable(){
458                  public void run(){                  public void run(){
459                      try{                      try{
460                          ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);                          ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);
461                          threadFail("should throw");                          threadShouldThrow();
462                      } catch(InterruptedException success){}                      } catch(InterruptedException success){}
463                      catch(Exception e){                      catch(Exception e){
464                          threadFail("unexpected exception");                          threadUnexpectedException();
465                      }                      }
466                  }                  }
467              });              });
# Line 405  Line 471 
471              t.interrupt();              t.interrupt();
472              t.join();              t.join();
473          } catch(Exception e){          } catch(Exception e){
474              fail("unexpected exception");              unexpectedException();
475          }          }
476      }      }
477    
478        /**
479         *
480         */
481      public void testGet_TimeoutException(){      public void testGet_TimeoutException(){
482          try{          try{
483              FutureTask ft = new FutureTask(new NoOpCallable());              FutureTask ft = new FutureTask(new NoOpCallable());
484              ft.get(1,TimeUnit.MILLISECONDS);              ft.get(1,TimeUnit.MILLISECONDS);
485              fail("should throw");              shouldThrow();
486          } catch(TimeoutException success){}          } catch(TimeoutException success){}
487          catch(Exception success){          catch(Exception success){
488              fail("unexpected exception");              unexpectedException();
489          }          }
490      }      }
491    

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8