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

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

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

revision 1.3, Fri Dec 19 14:44:25 2003 UTC revision 1.4, Fri Dec 19 20:38:55 2003 UTC
# Line 48  Line 48 
48              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
49              TrackedShortRunnable task = new TrackedShortRunnable();              TrackedShortRunnable task = new TrackedShortRunnable();
50              assertFalse(task.done);              assertFalse(task.done);
51              Future<?> future = e.submit(task, null);              Future<?> future = e.submit(task);
52              future.get();              future.get();
53              assertTrue(task.done);              assertTrue(task.done);
54          }          }
# Line 60  Line 60 
60          }          }
61      }      }
62    
     /**  
      * invoke of a runnable runs it to completion  
      */  
     public void testInvokeRunnable() {  
         try {  
             ExecutorService e = new DirectExecutorService();  
             TrackedShortRunnable task = new TrackedShortRunnable();  
             assertFalse(task.done);  
             e.invoke(task);  
             assertTrue(task.done);  
         }  
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
     }  
63    
64      /**      /**
65       * execute of a callable runs it to completion       * execute of a callable runs it to completion
# Line 188  Line 170 
170      }      }
171    
172      /**      /**
173       * invoke of a collable runs it to completion       * invoke of a callable runs it to completion
174       */       */
175      public void testInvokeCallable() {      public void testInvokeCallable() {
176          try {          try {
# Line 212  Line 194 
194          try {          try {
195              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
196              TrackedShortRunnable task = null;              TrackedShortRunnable task = null;
197              Future<?> future = e.submit(task, null);              Future<?> future = e.submit(task);
198              shouldThrow();              shouldThrow();
199          }          }
200          catch (NullPointerException success) {          catch (NullPointerException success) {
# Line 222  Line 204 
204          }          }
205      }      }
206    
     /**  
      * invoke of a null runnable throws NPE  
      */  
     public void testInvokeNullRunnable() {  
         try {  
             ExecutorService e = new DirectExecutorService();  
             TrackedShortRunnable task = null;  
             e.invoke(task);  
             shouldThrow();  
         }  
         catch (NullPointerException success) {  
         }  
         catch (Exception ex) {  
             unexpectedException();  
         }  
     }  
207    
208      /**      /**
209       * execute of a null callable throws NPE       * execute of a null callable throws NPE
# Line 282  Line 248 
248          try {          try {
249    
250              for(int i = 0; i < 5; ++i){              for(int i = 0; i < 5; ++i){
251                  p.submit(new MediumRunnable(), null);                  p.submit(new MediumRunnable());
252              }              }
253              shouldThrow();              shouldThrow();
254          } catch(RejectedExecutionException success){}          } catch(RejectedExecutionException success){}
# Line 306  Line 272 
272    
273    
274      /**      /**
275       *  invoke(Executor, Runnable) throws InterruptedException if       *  invoke(Executor, Callable) throws InterruptedException if
276       *  caller interrupted.       *  caller interrupted.
277       */       */
278      public void testInterruptedInvoke() {      public void testInterruptedInvoke() {
# Line 314  Line 280 
280          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
281                  public void run() {                  public void run() {
282                      try {                      try {
283                          p.invoke(new Runnable() {                          p.invoke(new Callable<Object>() {
284                                  public void run() {                                  public Object call() {
285                                      try {                                      try {
286                                          Thread.sleep(MEDIUM_DELAY_MS);                                          Thread.sleep(MEDIUM_DELAY_MS);
287                                          shouldThrow();                                          shouldThrow();
288                                      } catch(InterruptedException e){                                      } catch(InterruptedException e){
289                                      }                                      }
290                                        return null;
291                                  }                                  }
292                              });                              });
293                      } catch(InterruptedException success){                      } catch(InterruptedException success){
# Line 341  Line 308 
308      }      }
309    
310      /**      /**
      *  invoke(Executor, Runnable) throws ExecutionException if  
      *  runnable throws exception.  
      */  
     public void testInvoke3() {  
         ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));  
         try {  
             Runnable r = new Runnable() {  
                     public void run() {  
                         int i = 5/0;  
                     }  
                 };  
   
             for(int i =0; i < 5; i++){  
                 p.invoke(r);  
             }  
   
             shouldThrow();  
         } catch(ExecutionException success){  
         } catch(Exception e){  
             unexpectedException();  
         }  
         joinPool(p);  
     }  
   
   
   
     /**  
311       *  invoke(Executor, Callable) throws InterruptedException if       *  invoke(Executor, Callable) throws InterruptedException if
312       *  callable throws exception       *  callable throws exception
313       */       */

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8