[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.8, Mon Dec 22 00:48:55 2003 UTC
# Line 21  Line 21 
21      /**      /**
22       * Subclass to expose protected methods       * Subclass to expose protected methods
23       */       */
24      static class MyFutureTask extends FutureTask {      static class PublicFutureTask extends FutureTask {
25          public MyFutureTask(Callable r) { super(r); }          public PublicFutureTask(Callable r) { super(r); }
26          public boolean reset() { return super.reset(); }          public boolean reset() { return super.reset(); }
27          public void setCancelled() { super.setCancelled(); }          public void setCancelled() { super.setCancelled(); }
         public void setDone() { super.setDone(); }  
28          public void set(Object x) { super.set(x); }          public void set(Object x) { super.set(x); }
29          public void setException(Throwable t) { super.setException(t); }          public void setException(Throwable t) { super.setException(t); }
30      }      }
31    
32        /**
33         * Creating a future with a null callable throws NPE
34         */
35      public void testConstructor(){      public void testConstructor(){
36          try {          try {
37              FutureTask task = new FutureTask(null);              FutureTask task = new FutureTask(null);
38              fail("should throw");              shouldThrow();
39          }          }
40          catch(NullPointerException success) {          catch(NullPointerException success) {
41          }          }
42      }      }
43    
44        /**
45         * creating a future with null runnable fails
46         */
47      public void testConstructor2(){      public void testConstructor2(){
48          try {          try {
49              FutureTask task = new FutureTask(null, Boolean.TRUE);              FutureTask task = new FutureTask(null, Boolean.TRUE);
50              fail("should throw");              shouldThrow();
51          }          }
52          catch(NullPointerException success) {          catch(NullPointerException success) {
53          }          }
54      }      }
55    
56        /**
57         * isDone is true when a task completes
58         */
59      public void testIsDone(){      public void testIsDone(){
60          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
61          task.run();          task.run();
# Line 55  Line 63 
63          assertFalse(task.isCancelled());          assertFalse(task.isCancelled());
64      }      }
65    
66        /**
67         * reset of a done task succeeds and changes status to not done
68         */
69      public void testReset(){      public void testReset(){
70          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
71          task.run();          task.run();
72          assertTrue(task.isDone());          assertTrue(task.isDone());
73          assertTrue(task.reset());          assertTrue(task.reset());
74            assertFalse(task.isDone());
75      }      }
76    
77        /**
78         * Resetting after cancellation fails
79         */
80      public void testResetAfterCancel() {      public void testResetAfterCancel() {
81          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
82          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
83          task.run();          task.run();
84          assertTrue(task.isDone());          assertTrue(task.isDone());
# Line 71  Line 86 
86          assertFalse(task.reset());          assertFalse(task.reset());
87      }      }
88    
     public void testSetDone() {  
         MyFutureTask task = new MyFutureTask(new NoOpCallable());  
         task.setDone();  
         assertTrue(task.isDone());  
         assertFalse(task.isCancelled());  
     }  
89    
90        /**
91         * setCancelled of a new task causes isCancelled to be true
92         */
93      public void testSetCancelled() {      public void testSetCancelled() {
94          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
95          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
96          task.setCancelled();          task.setCancelled();
97          assertTrue(task.isDone());          assertTrue(task.isDone());
98          assertTrue(task.isCancelled());          assertTrue(task.isCancelled());
99      }      }
100    
101        /**
102         * setting value gauses get to return it
103         */
104      public void testSet() {      public void testSet() {
105          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
106          task.set(one);          task.set(one);
107          try {          try {
108              assertEquals(task.get(), one);              assertEquals(task.get(), one);
109          }          }
110          catch(Exception e) {          catch(Exception e) {
111              fail("unexpected exception");              unexpectedException();
112          }          }
113      }      }
114    
115        /**
116         * setException causes get to throw ExecutionException
117         */
118      public void testSetException() {      public void testSetException() {
119          Exception nse = new NoSuchElementException();          Exception nse = new NoSuchElementException();
120          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
121          task.setException(nse);          task.setException(nse);
122          try {          try {
123              Object x = task.get();              Object x = task.get();
124              fail("should throw");              shouldThrow();
125          }          }
126          catch(ExecutionException ee) {          catch(ExecutionException ee) {
127              Throwable cause = ee.getCause();              Throwable cause = ee.getCause();
128              assertEquals(cause, nse);              assertEquals(cause, nse);
129          }          }
130          catch(Exception e) {          catch(Exception e) {
131              fail("unexpected exception");              unexpectedException();
132          }          }
133      }      }
134    
135        /**
136         *  Cancelling before running succeeds
137         */
138      public void testCancelBeforeRun() {      public void testCancelBeforeRun() {
139          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
140          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
# Line 122  Line 143 
143          assertTrue(task.isCancelled());          assertTrue(task.isCancelled());
144      }      }
145    
146        /**
147         * Cancel(true) before run succeeds
148         */
149      public void testCancelBeforeRun2() {      public void testCancelBeforeRun2() {
150          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
151          assertTrue(task.cancel(true));          assertTrue(task.cancel(true));
# Line 130  Line 154 
154          assertTrue(task.isCancelled());          assertTrue(task.isCancelled());
155      }      }
156    
157        /**
158         * cancel of a completed task fails
159         */
160      public void testCancelAfterRun() {      public void testCancelAfterRun() {
161          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
162          task.run();          task.run();
# Line 138  Line 165 
165          assertFalse(task.isCancelled());          assertFalse(task.isCancelled());
166      }      }
167    
168        /**
169         * cancel(true) interrupts a running task
170         */
171      public void testCancelInterrupt(){      public void testCancelInterrupt(){
172          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new Callable() {
173                  public Object call() {                  public Object call() {
174                      try {                      try {
175                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
176                          threadFail("should throw");                          threadShouldThrow();
177                      }                      }
178                      catch (InterruptedException success) {}                      catch (InterruptedException success) {}
179                      return Boolean.TRUE;                      return Boolean.TRUE;
# Line 158  Line 188 
188              assertTrue(task.isDone());              assertTrue(task.isDone());
189              assertTrue(task.isCancelled());              assertTrue(task.isCancelled());
190          } catch(InterruptedException e){          } catch(InterruptedException e){
191              fail("unexpected exception");              unexpectedException();
192          }          }
193      }      }
194    
195    
196        /**
197         * cancel(false) does not interrupt a running task
198         */
199      public void testCancelNoInterrupt(){      public void testCancelNoInterrupt(){
200          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new Callable() {
201                  public Object call() {                  public Object call() {
# Line 184  Line 217 
217              assertTrue(task.isDone());              assertTrue(task.isDone());
218              assertTrue(task.isCancelled());              assertTrue(task.isCancelled());
219          } catch(InterruptedException e){          } catch(InterruptedException e){
220              fail("unexpected exception");              unexpectedException();
221          }          }
222      }      }
223    
224        /**
225         * set in one thread causes get in another thread to retrieve value
226         */
227      public void testGet1() {      public void testGet1() {
228          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
229                  public Object call(){                  public Object call(){
230                      try{                      try{
231                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
232                      } catch(InterruptedException e){                      } catch(InterruptedException e){
233                          threadFail("unexpected exception");                          threadUnexpectedException();
234                      }                      }
235                      return Boolean.TRUE;                      return Boolean.TRUE;
236                  }                  }
# Line 204  Line 240 
240                      try{                      try{
241                          ft.get();                          ft.get();
242                      } catch(Exception e){                      } catch(Exception e){
243                          threadFail("unexpected exception");                          threadUnexpectedException();
244                      }                      }
245                  }                  }
246              });              });
# Line 218  Line 254 
254              assertTrue(ft.isDone());              assertTrue(ft.isDone());
255              assertFalse(ft.isCancelled());              assertFalse(ft.isCancelled());
256          } catch(InterruptedException e){          } catch(InterruptedException e){
257              fail("unexpected exception");              unexpectedException();
258    
259          }          }
260      }      }
261    
262        /**
263         * set in one thread causes timed get in another thread to retrieve value
264         */
265      public void testTimedGet1() {      public void testTimedGet1() {
266          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
267                  public Object call(){                  public Object call(){
268                      try{                      try{
269                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
270                      } catch(InterruptedException e){                      } catch(InterruptedException e){
271                          threadFail("unexpected exception");                          threadUnexpectedException();
272                      }                      }
273                      return Boolean.TRUE;                      return Boolean.TRUE;
274                  }                  }
# Line 240  Line 279 
279                          ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);                          ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
280                      } catch(TimeoutException success) {                      } catch(TimeoutException success) {
281                      } catch(Exception e){                      } catch(Exception e){
282                          threadFail("unexpected exception");                          threadUnexpectedException();
283                      }                      }
284                  }                  }
285              });              });
# Line 253  Line 292 
292              assertTrue(ft.isDone());              assertTrue(ft.isDone());
293              assertFalse(ft.isCancelled());              assertFalse(ft.isCancelled());
294          } catch(InterruptedException e){          } catch(InterruptedException e){
295              fail("unexpected exception");              unexpectedException();
296    
297          }          }
298      }      }
299    
300        /**
301      public void testGet_Cancellation(){       *  Cancelling a task causes timed get in another thread to throw CancellationException
302         */
303        public void testTimedGet_Cancellation() {
304          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
305                  public Object call(){                  public Object call(){
306                      try{                      try{
307                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(SMALL_DELAY_MS);
308                            threadShouldThrow();
309                      } catch(InterruptedException e){                      } catch(InterruptedException e){
                         threadFail("unexpected exception");  
310                      }                      }
311                      return Boolean.TRUE;                      return Boolean.TRUE;
312                  }                  }
313              });              });
314          try {          try {
315              Thread.sleep(SHORT_DELAY_MS);              Thread t1 = new Thread(new Runnable() {
             Thread t = new Thread(new Runnable(){  
316                      public void run(){                      public void run(){
317                          try{                          try{
318                              ft.get();                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
319                              threadFail("should throw");                              threadShouldThrow();
320                          } catch(CancellationException success){                          } catch(CancellationException success) {}
                         }  
321                          catch(Exception e){                          catch(Exception e){
322                              threadFail("unexpected exception");                              threadUnexpectedException();
323                          }                          }
324                      }                      }
325                  });                  });
326              t.start();              Thread t2 = new Thread(ft);
327                t1.start();
328                t2.start();
329                Thread.sleep(SHORT_DELAY_MS);
330              ft.cancel(true);              ft.cancel(true);
331              t.join();              t1.join();
332          } catch(InterruptedException success){              t2.join();
333              fail("unexpected exception");          } catch(InterruptedException ie){
334                unexpectedException();
335          }          }
336      }      }
337    
338      public void testGet_Cancellation2(){      /**
339         * Cancelling a task causes get in another thread to throw CancellationException
340         */
341        public void testGet_Cancellation() {
342          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
343                  public Object call(){                  public Object call(){
344                      try{                      try{
345                          Thread.sleep(SHORT_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
346                            threadShouldThrow();
347                      } catch(InterruptedException e) {                      } catch(InterruptedException e) {
                         threadFail("unexpected exception");  
348                      }                      }
349                      return Boolean.TRUE;                      return Boolean.TRUE;
350                  }                  }
351              });              });
352          try{          try{
353              Thread.sleep(SHORT_DELAY_MS);              Thread t1 = new Thread(new Runnable() {
             Thread t = new Thread(new Runnable(){  
354                      public void run(){                      public void run(){
355                          try{                          try{
356                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);                              ft.get();
357                              threadFail("should throw");                              threadShouldThrow();
358                          } catch(CancellationException success) {}                          } catch(CancellationException success){
359                            }
360                          catch(Exception e){                          catch(Exception e){
361                              threadFail("unexpected exception");                              threadUnexpectedException();
362                          }                          }
363                      }                      }
364                  });                  });
365              t.start();              Thread t2 = new Thread(ft);
366                t1.start();
367                t2.start();
368              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
369              ft.cancel(true);              ft.cancel(true);
370              Thread.sleep(SHORT_DELAY_MS);              t1.join();
371              t.join();              t2.join();
372          } catch(InterruptedException ie){          } catch(InterruptedException success){
373              fail("unexpected exception");              unexpectedException();
374          }          }
375      }      }
376    
377    
378        /**
379         * A runtime exception in task causes get to throw ExecutionException
380         */
381      public void testGet_ExecutionException(){      public void testGet_ExecutionException(){
382          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
383                  public Object call(){                  public Object call(){
# Line 336  Line 388 
388          try{          try{
389              ft.run();              ft.run();
390              ft.get();              ft.get();
391              fail("should throw");              shouldThrow();
392          } catch(ExecutionException success){          } catch(ExecutionException success){
393          }          }
394          catch(Exception e){          catch(Exception e){
395              fail("unexpected exception");              unexpectedException();
396          }          }
397      }      }
398    
399        /**
400         *  A runtime exception in task causes timed get to throw ExecutionException
401         */
402      public void testTimedGet_ExecutionException2(){      public void testTimedGet_ExecutionException2(){
403          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
404                  public Object call(){                  public Object call(){
# Line 354  Line 409 
409          try{          try{
410              ft.run();              ft.run();
411              ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);              ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
412              fail("should throw");              shouldThrow();
413          } catch(ExecutionException success) {          } catch(ExecutionException success) {
414          } catch(TimeoutException success) { } // unlikely but OK          } catch(TimeoutException success) { } // unlikely but OK
415          catch(Exception e){          catch(Exception e){
416              fail("unexpected exception");              unexpectedException();
417          }          }
418      }      }
419    
420    
421        /**
422         * Interrupting a waiting get causes it to throw InterruptedException
423         */
424      public void testGet_InterruptedException(){      public void testGet_InterruptedException(){
425          final FutureTask ft = new FutureTask(new NoOpCallable());          final FutureTask ft = new FutureTask(new NoOpCallable());
426          Thread t = new Thread(new Runnable(){          Thread t = new Thread(new Runnable(){
427                  public void run(){                  public void run(){
428                      try{                      try{
429                          ft.get();                          ft.get();
430                          threadFail("should throw");                          threadShouldThrow();
431                      } catch(InterruptedException success){                      } catch(InterruptedException success){
432                      } catch(Exception e){                      } catch(Exception e){
433                          threadFail("unexpected exception");                          threadUnexpectedException();
434                      }                      }
435                  }                  }
436              });              });
# Line 382  Line 440 
440              t.interrupt();              t.interrupt();
441              t.join();              t.join();
442          } catch(Exception e){          } catch(Exception e){
443              fail("unexpected exception");              unexpectedException();
444          }          }
445      }      }
446    
447        /**
448         *  Interrupting a waiting timed get causes it to throw InterruptedException
449         */
450      public void testTimedGet_InterruptedException2(){      public void testTimedGet_InterruptedException2(){
451          final FutureTask ft = new FutureTask(new NoOpCallable());          final FutureTask ft = new FutureTask(new NoOpCallable());
452          Thread t = new Thread(new Runnable(){          Thread t = new Thread(new Runnable(){
453                  public void run(){                  public void run(){
454                      try{                      try{
455                          ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);                          ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);
456                          threadFail("should throw");                          threadShouldThrow();
457                      } catch(InterruptedException success){}                      } catch(InterruptedException success){}
458                      catch(Exception e){                      catch(Exception e){
459                          threadFail("unexpected exception");                          threadUnexpectedException();
460                      }                      }
461                  }                  }
462              });              });
# Line 405  Line 466 
466              t.interrupt();              t.interrupt();
467              t.join();              t.join();
468          } catch(Exception e){          } catch(Exception e){
469              fail("unexpected exception");              unexpectedException();
470          }          }
471      }      }
472    
473        /**
474         * A timed out timed get throws TimeoutException
475         */
476      public void testGet_TimeoutException(){      public void testGet_TimeoutException(){
477          try{          try{
478              FutureTask ft = new FutureTask(new NoOpCallable());              FutureTask ft = new FutureTask(new NoOpCallable());
479              ft.get(1,TimeUnit.MILLISECONDS);              ft.get(1,TimeUnit.MILLISECONDS);
480              fail("should throw");              shouldThrow();
481          } catch(TimeoutException success){}          } catch(TimeoutException success){}
482          catch(Exception success){          catch(Exception success){
483              fail("unexpected exception");              unexpectedException();
484          }          }
485      }      }
486    

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8