ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java (file contents):
Revision 1.1 by dl, Fri May 20 16:30:17 2005 UTC vs.
Revision 1.3 by jsr166, Mon Nov 16 04:57:10 2009 UTC

# Line 2 | Line 2
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4   * http://creativecommons.org/licenses/publicdomain
5 < * Other contributors include Andrew Wright, Jeffrey Hayes,
6 < * Pat Fisher, Mike Judd.
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9   import java.util.concurrent.*;
# Line 14 | Line 14 | import java.util.*;
14  
15   public class ThreadPoolExecutorSubclassTest extends JSR166TestCase {
16      public static void main(String[] args) {
17 <        junit.textui.TestRunner.run (suite());  
17 >        junit.textui.TestRunner.run (suite());
18      }
19      public static Test suite() {
20          return new TestSuite(ThreadPoolExecutorTest.class);
# Line 31 | Line 31 | public class ThreadPoolExecutorSubclassT
31          Exception exception;
32          CustomTask(Callable<V> c) { callable = c; }
33          CustomTask(final Runnable r, final V res) { callable = new Callable<V>() {
34 <            public V call() throws Exception { r.run(); return res; }};
34 >            public V call() throws Exception { r.run(); return res; }};
35          }
36          public boolean isDone() {
37              lock.lock(); try { return done; } finally { lock.unlock() ; }
# Line 45 | Line 45 | public class ThreadPoolExecutorSubclassT
45                  if (!done) {
46                      cancelled = true;
47                      done = true;
48 <                    if (mayInterrupt && thread != null)
48 >                    if (mayInterrupt && thread != null)
49                          thread.interrupt();
50                      return true;
51                  }
# Line 68 | Line 68 | public class ThreadPoolExecutorSubclassT
68              try {
69                  v = callable.call();
70              }
71 <            catch(Exception ex) {
71 >            catch (Exception ex) {
72                  e = ex;
73              }
74              lock.lock();
# Line 84 | Line 84 | public class ThreadPoolExecutorSubclassT
84          public V get() throws InterruptedException, ExecutionException {
85              lock.lock();
86              try {
87 <                while (!done)
87 >                while (!done)
88                      cond.await();
89                  if (exception != null)
90                      throw new ExecutionException(exception);
# Line 109 | Line 109 | public class ThreadPoolExecutorSubclassT
109              }
110              finally { lock.unlock(); }
111          }
112 <    }            
112 >    }
113 >
114  
114    
115      static class CustomTPE extends ThreadPoolExecutor {
116          protected <V> RunnableFuture<V> newTaskFor(Callable<V> c) {
117              return new CustomTask<V>(c);
118          }
119          protected <V> RunnableFuture<V> newTaskFor(Runnable r, V v) {
120              return new CustomTask<V>(r, v);
121 <        }
122 <        
121 >        }
122 >
123          CustomTPE(int corePoolSize,
124                    int maximumPoolSize,
125                    long keepAliveTime,
126                    TimeUnit unit,
127                    BlockingQueue<Runnable> workQueue) {
128 <            super(corePoolSize, maximumPoolSize, keepAliveTime, unit,
128 >            super(corePoolSize, maximumPoolSize, keepAliveTime, unit,
129                    workQueue);
130          }
131          CustomTPE(int corePoolSize,
# Line 154 | Line 154 | public class ThreadPoolExecutorSubclassT
154                    BlockingQueue<Runnable> workQueue,
155                    ThreadFactory threadFactory,
156                    RejectedExecutionHandler handler) {
157 <            super(corePoolSize, maximumPoolSize, keepAliveTime, unit,
157 >            super(corePoolSize, maximumPoolSize, keepAliveTime, unit,
158                workQueue, threadFactory, handler);
159          }
160  
# Line 173 | Line 173 | public class ThreadPoolExecutorSubclassT
173          protected void terminated() {
174              terminatedCalled = true;
175          }
176 <        
176 >
177      }
178  
179      static class FailingThreadFactory implements ThreadFactory{
# Line 181 | Line 181 | public class ThreadPoolExecutorSubclassT
181          public Thread newThread(Runnable r){
182              if (++calls > 1) return null;
183              return new Thread(r);
184 <        }  
184 >        }
185      }
186 <    
186 >
187  
188      /**
189       *  execute successfully executes a runnable
# Line 195 | Line 195 | public class ThreadPoolExecutorSubclassT
195                      public void run() {
196                          try {
197                              Thread.sleep(SHORT_DELAY_MS);
198 <                        } catch(InterruptedException e){
198 >                        } catch (InterruptedException e){
199                              threadUnexpectedException();
200                          }
201                      }
202                  });
203              Thread.sleep(SMALL_DELAY_MS);
204 <        } catch(InterruptedException e){
204 >        } catch (InterruptedException e){
205              unexpectedException();
206 <        }
206 >        }
207          joinPool(p1);
208      }
209  
# Line 217 | Line 217 | public class ThreadPoolExecutorSubclassT
217          p2.execute(new MediumRunnable());
218          try {
219              Thread.sleep(SHORT_DELAY_MS);
220 <        } catch(Exception e){
220 >        } catch (Exception e){
221              unexpectedException();
222          }
223          assertEquals(1, p2.getActiveCount());
# Line 251 | Line 251 | public class ThreadPoolExecutorSubclassT
251          assertEquals(2, p2.getPoolSize());
252          joinPool(p2);
253      }
254 <    
254 >
255      /**
256       *   getCompletedTaskCount increases, but doesn't overestimate,
257       *   when tasks complete
# Line 262 | Line 262 | public class ThreadPoolExecutorSubclassT
262          p2.execute(new ShortRunnable());
263          try {
264              Thread.sleep(SMALL_DELAY_MS);
265 <        } catch(Exception e){
265 >        } catch (Exception e){
266              unexpectedException();
267          }
268          assertEquals(1, p2.getCompletedTaskCount());
269 <        try { p2.shutdown(); } catch(SecurityException ok) { return; }
269 >        try { p2.shutdown(); } catch (SecurityException ok) { return; }
270          joinPool(p2);
271      }
272 <    
272 >
273      /**
274       *   getCorePoolSize returns size given in constructor if not otherwise set
275       */
# Line 278 | Line 278 | public class ThreadPoolExecutorSubclassT
278          assertEquals(1, p1.getCorePoolSize());
279          joinPool(p1);
280      }
281 <    
281 >
282      /**
283       *   getKeepAliveTime returns value given in constructor if not otherwise set
284       */
# Line 289 | Line 289 | public class ThreadPoolExecutorSubclassT
289      }
290  
291  
292 <    /**
292 >    /**
293       * getThreadFactory returns factory in constructor if not set
294       */
295      public void testGetThreadFactory() {
# Line 299 | Line 299 | public class ThreadPoolExecutorSubclassT
299          joinPool(p);
300      }
301  
302 <    /**
302 >    /**
303       * setThreadFactory sets the thread factory returned by getThreadFactory
304       */
305      public void testSetThreadFactory() {
# Line 311 | Line 311 | public class ThreadPoolExecutorSubclassT
311      }
312  
313  
314 <    /**
314 >    /**
315       * setThreadFactory(null) throws NPE
316       */
317      public void testSetThreadFactoryNull() {
# Line 325 | Line 325 | public class ThreadPoolExecutorSubclassT
325          }
326      }
327  
328 <    /**
328 >    /**
329       * getRejectedExecutionHandler returns handler in constructor if not set
330       */
331      public void testGetRejectedExecutionHandler() {
# Line 335 | Line 335 | public class ThreadPoolExecutorSubclassT
335          joinPool(p);
336      }
337  
338 <    /**
338 >    /**
339       * setRejectedExecutionHandler sets the handler returned by
340       * getRejectedExecutionHandler
341       */
# Line 348 | Line 348 | public class ThreadPoolExecutorSubclassT
348      }
349  
350  
351 <    /**
351 >    /**
352       * setRejectedExecutionHandler(null) throws NPE
353       */
354      public void testSetRejectedExecutionHandlerNull() {
# Line 362 | Line 362 | public class ThreadPoolExecutorSubclassT
362          }
363      }
364  
365 <    
365 >
366      /**
367       *   getLargestPoolSize increases, but doesn't overestimate, when
368       *   multiple threads active
# Line 375 | Line 375 | public class ThreadPoolExecutorSubclassT
375              p2.execute(new MediumRunnable());
376              Thread.sleep(SHORT_DELAY_MS);
377              assertEquals(2, p2.getLargestPoolSize());
378 <        } catch(Exception e){
378 >        } catch (Exception e){
379              unexpectedException();
380 <        }
380 >        }
381          joinPool(p2);
382      }
383 <    
383 >
384      /**
385       *   getMaximumPoolSize returns value given in constructor if not
386       *   otherwise set
# Line 390 | Line 390 | public class ThreadPoolExecutorSubclassT
390          assertEquals(2, p2.getMaximumPoolSize());
391          joinPool(p2);
392      }
393 <    
393 >
394      /**
395       *   getPoolSize increases, but doesn't overestimate, when threads
396       *   become active
# Line 402 | Line 402 | public class ThreadPoolExecutorSubclassT
402          assertEquals(1, p1.getPoolSize());
403          joinPool(p1);
404      }
405 <    
405 >
406      /**
407       *  getTaskCount increases, but doesn't overestimate, when tasks submitted
408       */
# Line 413 | Line 413 | public class ThreadPoolExecutorSubclassT
413              p1.execute(new MediumRunnable());
414              Thread.sleep(SHORT_DELAY_MS);
415              assertEquals(1, p1.getTaskCount());
416 <        } catch(Exception e){
416 >        } catch (Exception e){
417              unexpectedException();
418 <        }
418 >        }
419          joinPool(p1);
420      }
421 <    
421 >
422      /**
423       *   isShutDown is false before shutdown, true after
424       */
425      public void testIsShutdown() {
426 <        
426 >
427          ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
428          assertFalse(p1.isShutdown());
429 <        try { p1.shutdown(); } catch(SecurityException ok) { return; }
429 >        try { p1.shutdown(); } catch (SecurityException ok) { return; }
430          assertTrue(p1.isShutdown());
431          joinPool(p1);
432      }
433  
434 <        
434 >
435      /**
436       *  isTerminated is false before termination, true after
437       */
# Line 441 | Line 441 | public class ThreadPoolExecutorSubclassT
441          try {
442              p1.execute(new MediumRunnable());
443          } finally {
444 <            try { p1.shutdown(); } catch(SecurityException ok) { return; }
444 >            try { p1.shutdown(); } catch (SecurityException ok) { return; }
445          }
446          try {
447              assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
448              assertTrue(p1.isTerminated());
449 <        } catch(Exception e){
449 >        } catch (Exception e){
450              unexpectedException();
451 <        }      
451 >        }
452      }
453  
454      /**
# Line 461 | Line 461 | public class ThreadPoolExecutorSubclassT
461              p1.execute(new SmallRunnable());
462              assertFalse(p1.isTerminating());
463          } finally {
464 <            try { p1.shutdown(); } catch(SecurityException ok) { return; }
464 >            try { p1.shutdown(); } catch (SecurityException ok) { return; }
465          }
466          try {
467              assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
468              assertTrue(p1.isTerminated());
469              assertFalse(p1.isTerminating());
470 <        } catch(Exception e){
470 >        } catch (Exception e){
471              unexpectedException();
472 <        }      
472 >        }
473      }
474  
475      /**
# Line 479 | Line 479 | public class ThreadPoolExecutorSubclassT
479          BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
480          ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
481          FutureTask[] tasks = new FutureTask[5];
482 <        for(int i = 0; i < 5; i++){
482 >        for (int i = 0; i < 5; i++){
483              tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
484              p1.execute(tasks[i]);
485          }
# Line 492 | Line 492 | public class ThreadPoolExecutorSubclassT
492              for (int i = 1; i < 5; ++i)
493                  tasks[i].cancel(true);
494              p1.shutdownNow();
495 <        } catch(Exception e) {
495 >        } catch (Exception e) {
496              unexpectedException();
497          } finally {
498              joinPool(p1);
# Line 506 | Line 506 | public class ThreadPoolExecutorSubclassT
506          BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
507          ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
508          FutureTask[] tasks = new FutureTask[5];
509 <        for(int i = 0; i < 5; i++){
509 >        for (int i = 0; i < 5; i++){
510              tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
511              p1.execute(tasks[i]);
512          }
# Line 521 | Line 521 | public class ThreadPoolExecutorSubclassT
521              assertTrue(q.contains(tasks[3]));
522              assertTrue(p1.remove(tasks[3]));
523              assertFalse(q.contains(tasks[3]));
524 <        } catch(Exception e) {
524 >        } catch (Exception e) {
525              unexpectedException();
526          } finally {
527              joinPool(p1);
# Line 534 | Line 534 | public class ThreadPoolExecutorSubclassT
534      public void testPurge() {
535          ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
536          FutureTask[] tasks = new FutureTask[5];
537 <        for(int i = 0; i < 5; i++){
537 >        for (int i = 0; i < 5; i++){
538              tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
539              p1.execute(tasks[i]);
540          }
# Line 553 | Line 553 | public class ThreadPoolExecutorSubclassT
553          ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
554          List l;
555          try {
556 <            for(int i = 0; i < 5; i++)
556 >            for (int i = 0; i < 5; i++)
557                  p1.execute(new MediumPossiblyInterruptedRunnable());
558          }
559          finally {
560              try {
561                  l = p1.shutdownNow();
562              } catch (SecurityException ok) { return; }
563 <            
563 >
564          }
565          assertTrue(p1.isShutdown());
566          assertTrue(l.size() <= 4);
567      }
568  
569      // Exception Tests
570    
570  
571 <    /**
572 <     * Constructor throws if corePoolSize argument is less than zero
571 >
572 >    /**
573 >     * Constructor throws if corePoolSize argument is less than zero
574       */
575      public void testConstructor1() {
576          try {
# Line 579 | Line 579 | public class ThreadPoolExecutorSubclassT
579          }
580          catch (IllegalArgumentException success){}
581      }
582 <    
583 <    /**
584 <     * Constructor throws if maximumPoolSize is less than zero
582 >
583 >    /**
584 >     * Constructor throws if maximumPoolSize is less than zero
585       */
586      public void testConstructor2() {
587          try {
# Line 590 | Line 590 | public class ThreadPoolExecutorSubclassT
590          }
591          catch (IllegalArgumentException success){}
592      }
593 <    
594 <    /**
595 <     * Constructor throws if maximumPoolSize is equal to zero
593 >
594 >    /**
595 >     * Constructor throws if maximumPoolSize is equal to zero
596       */
597      public void testConstructor3() {
598          try {
# Line 602 | Line 602 | public class ThreadPoolExecutorSubclassT
602          catch (IllegalArgumentException success){}
603      }
604  
605 <    /**
606 <     * Constructor throws if keepAliveTime is less than zero
605 >    /**
606 >     * Constructor throws if keepAliveTime is less than zero
607       */
608      public void testConstructor4() {
609          try {
# Line 613 | Line 613 | public class ThreadPoolExecutorSubclassT
613          catch (IllegalArgumentException success){}
614      }
615  
616 <    /**
617 <     * Constructor throws if corePoolSize is greater than the maximumPoolSize
616 >    /**
617 >     * Constructor throws if corePoolSize is greater than the maximumPoolSize
618       */
619      public void testConstructor5() {
620          try {
# Line 623 | Line 623 | public class ThreadPoolExecutorSubclassT
623          }
624          catch (IllegalArgumentException success){}
625      }
626 <        
627 <    /**
628 <     * Constructor throws if workQueue is set to null
626 >
627 >    /**
628 >     * Constructor throws if workQueue is set to null
629       */
630      public void testConstructorNullPointerException() {
631          try {
632              new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null);
633              shouldThrow();
634          }
635 <        catch (NullPointerException success){}  
635 >        catch (NullPointerException success){}
636      }
637    
637  
638 <    
639 <    /**
640 <     * Constructor throws if corePoolSize argument is less than zero
638 >
639 >
640 >    /**
641 >     * Constructor throws if corePoolSize argument is less than zero
642       */
643      public void testConstructor6() {
644          try {
# Line 646 | Line 646 | public class ThreadPoolExecutorSubclassT
646              shouldThrow();
647          } catch (IllegalArgumentException success){}
648      }
649 <    
650 <    /**
651 <     * Constructor throws if maximumPoolSize is less than zero
649 >
650 >    /**
651 >     * Constructor throws if maximumPoolSize is less than zero
652       */
653      public void testConstructor7() {
654          try {
# Line 658 | Line 658 | public class ThreadPoolExecutorSubclassT
658          catch (IllegalArgumentException success){}
659      }
660  
661 <    /**
662 <     * Constructor throws if maximumPoolSize is equal to zero
661 >    /**
662 >     * Constructor throws if maximumPoolSize is equal to zero
663       */
664      public void testConstructor8() {
665          try {
# Line 669 | Line 669 | public class ThreadPoolExecutorSubclassT
669          catch (IllegalArgumentException success){}
670      }
671  
672 <    /**
673 <     * Constructor throws if keepAliveTime is less than zero
672 >    /**
673 >     * Constructor throws if keepAliveTime is less than zero
674       */
675      public void testConstructor9() {
676          try {
# Line 680 | Line 680 | public class ThreadPoolExecutorSubclassT
680          catch (IllegalArgumentException success){}
681      }
682  
683 <    /**
684 <     * Constructor throws if corePoolSize is greater than the maximumPoolSize
683 >    /**
684 >     * Constructor throws if corePoolSize is greater than the maximumPoolSize
685       */
686      public void testConstructor10() {
687          try {
# Line 691 | Line 691 | public class ThreadPoolExecutorSubclassT
691          catch (IllegalArgumentException success){}
692      }
693  
694 <    /**
695 <     * Constructor throws if workQueue is set to null
694 >    /**
695 >     * Constructor throws if workQueue is set to null
696       */
697      public void testConstructorNullPointerException2() {
698          try {
699              new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory());
700              shouldThrow();
701          }
702 <        catch (NullPointerException success){}  
702 >        catch (NullPointerException success){}
703      }
704  
705 <    /**
706 <     * Constructor throws if threadFactory is set to null
705 >    /**
706 >     * Constructor throws if threadFactory is set to null
707       */
708      public void testConstructorNullPointerException3() {
709          try {
# Line 711 | Line 711 | public class ThreadPoolExecutorSubclassT
711              new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
712              shouldThrow();
713          }
714 <        catch (NullPointerException success){}  
714 >        catch (NullPointerException success){}
715      }
716 <
717 <    
718 <    /**
719 <     * Constructor throws if corePoolSize argument is less than zero
716 >
717 >
718 >    /**
719 >     * Constructor throws if corePoolSize argument is less than zero
720       */
721      public void testConstructor11() {
722          try {
# Line 726 | Line 726 | public class ThreadPoolExecutorSubclassT
726          catch (IllegalArgumentException success){}
727      }
728  
729 <    /**
730 <     * Constructor throws if maximumPoolSize is less than zero
729 >    /**
730 >     * Constructor throws if maximumPoolSize is less than zero
731       */
732      public void testConstructor12() {
733          try {
# Line 737 | Line 737 | public class ThreadPoolExecutorSubclassT
737          catch (IllegalArgumentException success){}
738      }
739  
740 <    /**
741 <     * Constructor throws if maximumPoolSize is equal to zero
740 >    /**
741 >     * Constructor throws if maximumPoolSize is equal to zero
742       */
743      public void testConstructor13() {
744          try {
# Line 748 | Line 748 | public class ThreadPoolExecutorSubclassT
748          catch (IllegalArgumentException success){}
749      }
750  
751 <    /**
752 <     * Constructor throws if keepAliveTime is less than zero
751 >    /**
752 >     * Constructor throws if keepAliveTime is less than zero
753       */
754      public void testConstructor14() {
755          try {
# Line 759 | Line 759 | public class ThreadPoolExecutorSubclassT
759          catch (IllegalArgumentException success){}
760      }
761  
762 <    /**
763 <     * Constructor throws if corePoolSize is greater than the maximumPoolSize
762 >    /**
763 >     * Constructor throws if corePoolSize is greater than the maximumPoolSize
764       */
765      public void testConstructor15() {
766          try {
# Line 770 | Line 770 | public class ThreadPoolExecutorSubclassT
770          catch (IllegalArgumentException success){}
771      }
772  
773 <    /**
774 <     * Constructor throws if workQueue is set to null
773 >    /**
774 >     * Constructor throws if workQueue is set to null
775       */
776      public void testConstructorNullPointerException4() {
777          try {
778              new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new NoOpREHandler());
779              shouldThrow();
780          }
781 <        catch (NullPointerException success){}  
781 >        catch (NullPointerException success){}
782      }
783  
784 <    /**
785 <     * Constructor throws if handler is set to null
784 >    /**
785 >     * Constructor throws if handler is set to null
786       */
787      public void testConstructorNullPointerException5() {
788          try {
# Line 790 | Line 790 | public class ThreadPoolExecutorSubclassT
790              new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
791              shouldThrow();
792          }
793 <        catch (NullPointerException success){}  
793 >        catch (NullPointerException success){}
794      }
795  
796 <    
797 <    /**
798 <     * Constructor throws if corePoolSize argument is less than zero
796 >
797 >    /**
798 >     * Constructor throws if corePoolSize argument is less than zero
799       */
800      public void testConstructor16() {
801          try {
# Line 805 | Line 805 | public class ThreadPoolExecutorSubclassT
805          catch (IllegalArgumentException success){}
806      }
807  
808 <    /**
809 <     * Constructor throws if maximumPoolSize is less than zero
808 >    /**
809 >     * Constructor throws if maximumPoolSize is less than zero
810       */
811      public void testConstructor17() {
812          try {
# Line 816 | Line 816 | public class ThreadPoolExecutorSubclassT
816          catch (IllegalArgumentException success){}
817      }
818  
819 <    /**
820 <     * Constructor throws if maximumPoolSize is equal to zero
819 >    /**
820 >     * Constructor throws if maximumPoolSize is equal to zero
821       */
822      public void testConstructor18() {
823          try {
# Line 827 | Line 827 | public class ThreadPoolExecutorSubclassT
827          catch (IllegalArgumentException success){}
828      }
829  
830 <    /**
831 <     * Constructor throws if keepAliveTime is less than zero
830 >    /**
831 >     * Constructor throws if keepAliveTime is less than zero
832       */
833      public void testConstructor19() {
834          try {
# Line 838 | Line 838 | public class ThreadPoolExecutorSubclassT
838          catch (IllegalArgumentException success){}
839      }
840  
841 <    /**
842 <     * Constructor throws if corePoolSize is greater than the maximumPoolSize
841 >    /**
842 >     * Constructor throws if corePoolSize is greater than the maximumPoolSize
843       */
844      public void testConstructor20() {
845          try {
# Line 849 | Line 849 | public class ThreadPoolExecutorSubclassT
849          catch (IllegalArgumentException success){}
850      }
851  
852 <    /**
853 <     * Constructor throws if workQueue is set to null
852 >    /**
853 >     * Constructor throws if workQueue is set to null
854       */
855      public void testConstructorNullPointerException6() {
856          try {
857              new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler());
858              shouldThrow();
859          }
860 <        catch (NullPointerException success){}  
860 >        catch (NullPointerException success){}
861      }
862  
863 <    /**
864 <     * Constructor throws if handler is set to null
863 >    /**
864 >     * Constructor throws if handler is set to null
865       */
866      public void testConstructorNullPointerException7() {
867          try {
# Line 869 | Line 869 | public class ThreadPoolExecutorSubclassT
869              new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r);
870              shouldThrow();
871          }
872 <        catch (NullPointerException success){}  
872 >        catch (NullPointerException success){}
873      }
874  
875 <    /**
876 <     * Constructor throws if ThreadFactory is set top null
875 >    /**
876 >     * Constructor throws if ThreadFactory is set top null
877       */
878      public void testConstructorNullPointerException8() {
879          try {
# Line 881 | Line 881 | public class ThreadPoolExecutorSubclassT
881              new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler());
882              shouldThrow();
883          }
884 <        catch (NullPointerException successdn8){}  
884 >        catch (NullPointerException successdn8){}
885      }
886 <    
886 >
887  
888      /**
889       *  execute throws RejectedExecutionException
# Line 892 | Line 892 | public class ThreadPoolExecutorSubclassT
892      public void testSaturatedExecute() {
893          ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
894          try {
895 <            
896 <            for(int i = 0; i < 5; ++i){
895 >
896 >            for (int i = 0; i < 5; ++i){
897                  p.execute(new MediumRunnable());
898              }
899              shouldThrow();
900 <        } catch(RejectedExecutionException success){}
900 >        } catch (RejectedExecutionException success){}
901          joinPool(p);
902      }
903  
# Line 908 | Line 908 | public class ThreadPoolExecutorSubclassT
908          RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy();
909          ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
910          try {
911 <            
911 >
912              TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
913 <            for(int i = 0; i < 5; ++i){
913 >            for (int i = 0; i < 5; ++i){
914                  tasks[i] = new TrackedNoOpRunnable();
915              }
916              TrackedLongRunnable mr = new TrackedLongRunnable();
917              p.execute(mr);
918 <            for(int i = 0; i < 5; ++i){
918 >            for (int i = 0; i < 5; ++i){
919                  p.execute(tasks[i]);
920              }
921 <            for(int i = 1; i < 5; ++i) {
921 >            for (int i = 1; i < 5; ++i) {
922                  assertTrue(tasks[i].done);
923              }
924 <            try { p.shutdownNow(); } catch(SecurityException ok) { return; }
925 <        } catch(RejectedExecutionException ex){
924 >            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
925 >        } catch (RejectedExecutionException ex){
926              unexpectedException();
927          } finally {
928              joinPool(p);
# Line 936 | Line 936 | public class ThreadPoolExecutorSubclassT
936          RejectedExecutionHandler h = new CustomTPE.DiscardPolicy();
937          ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
938          try {
939 <            
939 >
940              TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
941 <            for(int i = 0; i < 5; ++i){
941 >            for (int i = 0; i < 5; ++i){
942                  tasks[i] = new TrackedNoOpRunnable();
943              }
944              p.execute(new TrackedLongRunnable());
945 <            for(int i = 0; i < 5; ++i){
945 >            for (int i = 0; i < 5; ++i){
946                  p.execute(tasks[i]);
947              }
948 <            for(int i = 0; i < 5; ++i){
948 >            for (int i = 0; i < 5; ++i){
949                  assertFalse(tasks[i].done);
950              }
951 <            try { p.shutdownNow(); } catch(SecurityException ok) { return; }
952 <        } catch(RejectedExecutionException ex){
951 >            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
952 >        } catch (RejectedExecutionException ex){
953              unexpectedException();
954          } finally {
955              joinPool(p);
# Line 971 | Line 971 | public class ThreadPoolExecutorSubclassT
971              p.execute(r3);
972              assertFalse(p.getQueue().contains(r2));
973              assertTrue(p.getQueue().contains(r3));
974 <            try { p.shutdownNow(); } catch(SecurityException ok) { return; }
975 <        } catch(RejectedExecutionException ex){
974 >            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
975 >        } catch (RejectedExecutionException ex){
976              unexpectedException();
977          } finally {
978              joinPool(p);
# Line 983 | Line 983 | public class ThreadPoolExecutorSubclassT
983       *  execute throws RejectedExecutionException if shutdown
984       */
985      public void testRejectedExecutionExceptionOnShutdown() {
986 <        ThreadPoolExecutor tpe =
986 >        ThreadPoolExecutor tpe =
987              new CustomTPE(1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
988 <        try { tpe.shutdown(); } catch(SecurityException ok) { return; }
988 >        try { tpe.shutdown(); } catch (SecurityException ok) { return; }
989          try {
990              tpe.execute(new NoOpRunnable());
991              shouldThrow();
992 <        } catch(RejectedExecutionException success){}
993 <        
992 >        } catch (RejectedExecutionException success){}
993 >
994          joinPool(tpe);
995      }
996  
# Line 1001 | Line 1001 | public class ThreadPoolExecutorSubclassT
1001          RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy();
1002          ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1003  
1004 <        try { p.shutdown(); } catch(SecurityException ok) { return; }
1004 >        try { p.shutdown(); } catch (SecurityException ok) { return; }
1005          try {
1006              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1007              p.execute(r);
1008              assertFalse(r.done);
1009 <        } catch(RejectedExecutionException success){
1009 >        } catch (RejectedExecutionException success){
1010              unexpectedException();
1011          } finally {
1012              joinPool(p);
# Line 1020 | Line 1020 | public class ThreadPoolExecutorSubclassT
1020          RejectedExecutionHandler h = new CustomTPE.DiscardPolicy();
1021          ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1022  
1023 <        try { p.shutdown(); } catch(SecurityException ok) { return; }
1023 >        try { p.shutdown(); } catch (SecurityException ok) { return; }
1024          try {
1025              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1026              p.execute(r);
1027              assertFalse(r.done);
1028 <        } catch(RejectedExecutionException success){
1028 >        } catch (RejectedExecutionException success){
1029              unexpectedException();
1030          } finally {
1031              joinPool(p);
# Line 1040 | Line 1040 | public class ThreadPoolExecutorSubclassT
1040          RejectedExecutionHandler h = new CustomTPE.DiscardOldestPolicy();
1041          ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1042  
1043 <        try { p.shutdown(); } catch(SecurityException ok) { return; }
1043 >        try { p.shutdown(); } catch (SecurityException ok) { return; }
1044          try {
1045              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1046              p.execute(r);
1047              assertFalse(r.done);
1048 <        } catch(RejectedExecutionException success){
1048 >        } catch (RejectedExecutionException success){
1049              unexpectedException();
1050          } finally {
1051              joinPool(p);
# Line 1062 | Line 1062 | public class ThreadPoolExecutorSubclassT
1062              tpe = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1063              tpe.execute(null);
1064              shouldThrow();
1065 <        } catch(NullPointerException success){}
1066 <        
1065 >        } catch (NullPointerException success){}
1066 >
1067          joinPool(tpe);
1068      }
1069 <    
1069 >
1070      /**
1071       *  setCorePoolSize of negative value throws IllegalArgumentException
1072       */
# Line 1074 | Line 1074 | public class ThreadPoolExecutorSubclassT
1074          ThreadPoolExecutor tpe = null;
1075          try {
1076              tpe = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1077 <        } catch(Exception e){}
1077 >        } catch (Exception e){}
1078          try {
1079              tpe.setCorePoolSize(-1);
1080              shouldThrow();
1081 <        } catch(IllegalArgumentException success){
1081 >        } catch (IllegalArgumentException success){
1082          } finally {
1083 <            try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1083 >            try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1084          }
1085          joinPool(tpe);
1086 <    }  
1086 >    }
1087  
1088      /**
1089       *  setMaximumPoolSize(int) throws IllegalArgumentException if
1090       *  given a value less the core pool size
1091 <     */  
1091 >     */
1092      public void testMaximumPoolSizeIllegalArgumentException() {
1093          ThreadPoolExecutor tpe = null;
1094          try {
1095              tpe = new CustomTPE(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1096 <        } catch(Exception e){}
1096 >        } catch (Exception e){}
1097          try {
1098              tpe.setMaximumPoolSize(1);
1099              shouldThrow();
1100 <        } catch(IllegalArgumentException success){
1100 >        } catch (IllegalArgumentException success){
1101          } finally {
1102 <            try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1102 >            try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1103          }
1104          joinPool(tpe);
1105      }
1106 <    
1106 >
1107      /**
1108       *  setMaximumPoolSize throws IllegalArgumentException
1109       *  if given a negative value
# Line 1112 | Line 1112 | public class ThreadPoolExecutorSubclassT
1112          ThreadPoolExecutor tpe = null;
1113          try {
1114              tpe = new CustomTPE(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1115 <        } catch(Exception e){}
1115 >        } catch (Exception e){}
1116          try {
1117              tpe.setMaximumPoolSize(-1);
1118              shouldThrow();
1119 <        } catch(IllegalArgumentException success){
1119 >        } catch (IllegalArgumentException success){
1120          } finally {
1121 <            try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1121 >            try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1122          }
1123          joinPool(tpe);
1124      }
1125 <    
1125 >
1126  
1127      /**
1128       *  setKeepAliveTime  throws IllegalArgumentException
# Line 1132 | Line 1132 | public class ThreadPoolExecutorSubclassT
1132          ThreadPoolExecutor tpe = null;
1133          try {
1134              tpe = new CustomTPE(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1135 <        } catch(Exception e){}
1136 <        
1135 >        } catch (Exception e){}
1136 >
1137          try {
1138              tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS);
1139              shouldThrow();
1140 <        } catch(IllegalArgumentException success){
1140 >        } catch (IllegalArgumentException success){
1141          } finally {
1142 <            try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1142 >            try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1143          }
1144          joinPool(tpe);
1145      }
# Line 1149 | Line 1149 | public class ThreadPoolExecutorSubclassT
1149       */
1150      public void testTerminated() {
1151          CustomTPE tpe = new CustomTPE();
1152 <        try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1152 >        try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1153          assertTrue(tpe.terminatedCalled);
1154          joinPool(tpe);
1155      }
# Line 1166 | Line 1166 | public class ThreadPoolExecutorSubclassT
1166              assertTrue(r.done);
1167              assertTrue(tpe.beforeCalled);
1168              assertTrue(tpe.afterCalled);
1169 <            try { tpe.shutdown(); } catch(SecurityException ok) { return; }
1169 >            try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1170          }
1171 <        catch(Exception ex) {
1171 >        catch (Exception ex) {
1172              unexpectedException();
1173          } finally {
1174              joinPool(tpe);
# Line 1247 | Line 1247 | public class ThreadPoolExecutorSubclassT
1247          try {
1248              e.invokeAny(null);
1249          } catch (NullPointerException success) {
1250 <        } catch(Exception ex) {
1250 >        } catch (Exception ex) {
1251              unexpectedException();
1252          } finally {
1253              joinPool(e);
# Line 1262 | Line 1262 | public class ThreadPoolExecutorSubclassT
1262          try {
1263              e.invokeAny(new ArrayList<Callable<String>>());
1264          } catch (IllegalArgumentException success) {
1265 <        } catch(Exception ex) {
1265 >        } catch (Exception ex) {
1266              unexpectedException();
1267          } finally {
1268              joinPool(e);
# Line 1280 | Line 1280 | public class ThreadPoolExecutorSubclassT
1280              l.add(null);
1281              e.invokeAny(l);
1282          } catch (NullPointerException success) {
1283 <        } catch(Exception ex) {
1283 >        } catch (Exception ex) {
1284              unexpectedException();
1285          } finally {
1286              joinPool(e);
# Line 1297 | Line 1297 | public class ThreadPoolExecutorSubclassT
1297              l.add(new NPETask());
1298              e.invokeAny(l);
1299          } catch (ExecutionException success) {
1300 <        } catch(Exception ex) {
1300 >        } catch (Exception ex) {
1301              unexpectedException();
1302          } finally {
1303              joinPool(e);
# Line 1316 | Line 1316 | public class ThreadPoolExecutorSubclassT
1316              String result = e.invokeAny(l);
1317              assertSame(TEST_STRING, result);
1318          } catch (ExecutionException success) {
1319 <        } catch(Exception ex) {
1319 >        } catch (Exception ex) {
1320              unexpectedException();
1321          } finally {
1322              joinPool(e);
# Line 1331 | Line 1331 | public class ThreadPoolExecutorSubclassT
1331          try {
1332              e.invokeAll(null);
1333          } catch (NullPointerException success) {
1334 <        } catch(Exception ex) {
1334 >        } catch (Exception ex) {
1335              unexpectedException();
1336          } finally {
1337              joinPool(e);
# Line 1346 | Line 1346 | public class ThreadPoolExecutorSubclassT
1346          try {
1347              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1348              assertTrue(r.isEmpty());
1349 <        } catch(Exception ex) {
1349 >        } catch (Exception ex) {
1350              unexpectedException();
1351          } finally {
1352              joinPool(e);
# Line 1364 | Line 1364 | public class ThreadPoolExecutorSubclassT
1364              l.add(null);
1365              e.invokeAll(l);
1366          } catch (NullPointerException success) {
1367 <        } catch(Exception ex) {
1367 >        } catch (Exception ex) {
1368              unexpectedException();
1369          } finally {
1370              joinPool(e);
# Line 1381 | Line 1381 | public class ThreadPoolExecutorSubclassT
1381              l.add(new NPETask());
1382              List<Future<String>> result = e.invokeAll(l);
1383              assertEquals(1, result.size());
1384 <            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1384 >            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1385                  it.next().get();
1386 <        } catch(ExecutionException success) {
1387 <        } catch(Exception ex) {
1386 >        } catch (ExecutionException success) {
1387 >        } catch (Exception ex) {
1388              unexpectedException();
1389          } finally {
1390              joinPool(e);
# Line 1402 | Line 1402 | public class ThreadPoolExecutorSubclassT
1402              l.add(new StringTask());
1403              List<Future<String>> result = e.invokeAll(l);
1404              assertEquals(2, result.size());
1405 <            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1405 >            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1406                  assertSame(TEST_STRING, it.next().get());
1407          } catch (ExecutionException success) {
1408 <        } catch(Exception ex) {
1408 >        } catch (Exception ex) {
1409              unexpectedException();
1410          } finally {
1411              joinPool(e);
# Line 1422 | Line 1422 | public class ThreadPoolExecutorSubclassT
1422          try {
1423              e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1424          } catch (NullPointerException success) {
1425 <        } catch(Exception ex) {
1425 >        } catch (Exception ex) {
1426              unexpectedException();
1427          } finally {
1428              joinPool(e);
# Line 1439 | Line 1439 | public class ThreadPoolExecutorSubclassT
1439              l.add(new StringTask());
1440              e.invokeAny(l, MEDIUM_DELAY_MS, null);
1441          } catch (NullPointerException success) {
1442 <        } catch(Exception ex) {
1442 >        } catch (Exception ex) {
1443              unexpectedException();
1444          } finally {
1445              joinPool(e);
# Line 1454 | Line 1454 | public class ThreadPoolExecutorSubclassT
1454          try {
1455              e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1456          } catch (IllegalArgumentException success) {
1457 <        } catch(Exception ex) {
1457 >        } catch (Exception ex) {
1458              unexpectedException();
1459          } finally {
1460              joinPool(e);
# Line 1472 | Line 1472 | public class ThreadPoolExecutorSubclassT
1472              l.add(null);
1473              e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1474          } catch (NullPointerException success) {
1475 <        } catch(Exception ex) {
1475 >        } catch (Exception ex) {
1476              ex.printStackTrace();
1477              unexpectedException();
1478          } finally {
# Line 1489 | Line 1489 | public class ThreadPoolExecutorSubclassT
1489              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1490              l.add(new NPETask());
1491              e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1492 <        } catch(ExecutionException success) {
1493 <        } catch(Exception ex) {
1492 >        } catch (ExecutionException success) {
1493 >        } catch (Exception ex) {
1494              unexpectedException();
1495          } finally {
1496              joinPool(e);
# Line 1509 | Line 1509 | public class ThreadPoolExecutorSubclassT
1509              String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1510              assertSame(TEST_STRING, result);
1511          } catch (ExecutionException success) {
1512 <        } catch(Exception ex) {
1512 >        } catch (Exception ex) {
1513              unexpectedException();
1514          } finally {
1515              joinPool(e);
# Line 1524 | Line 1524 | public class ThreadPoolExecutorSubclassT
1524          try {
1525              e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1526          } catch (NullPointerException success) {
1527 <        } catch(Exception ex) {
1527 >        } catch (Exception ex) {
1528              unexpectedException();
1529          } finally {
1530              joinPool(e);
# Line 1541 | Line 1541 | public class ThreadPoolExecutorSubclassT
1541              l.add(new StringTask());
1542              e.invokeAll(l, MEDIUM_DELAY_MS, null);
1543          } catch (NullPointerException success) {
1544 <        } catch(Exception ex) {
1544 >        } catch (Exception ex) {
1545              unexpectedException();
1546          } finally {
1547              joinPool(e);
# Line 1556 | Line 1556 | public class ThreadPoolExecutorSubclassT
1556          try {
1557              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1558              assertTrue(r.isEmpty());
1559 <        } catch(Exception ex) {
1559 >        } catch (Exception ex) {
1560              unexpectedException();
1561          } finally {
1562              joinPool(e);
# Line 1574 | Line 1574 | public class ThreadPoolExecutorSubclassT
1574              l.add(null);
1575              e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1576          } catch (NullPointerException success) {
1577 <        } catch(Exception ex) {
1577 >        } catch (Exception ex) {
1578              unexpectedException();
1579          } finally {
1580              joinPool(e);
# Line 1591 | Line 1591 | public class ThreadPoolExecutorSubclassT
1591              l.add(new NPETask());
1592              List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1593              assertEquals(1, result.size());
1594 <            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1594 >            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1595                  it.next().get();
1596 <        } catch(ExecutionException success) {
1597 <        } catch(Exception ex) {
1596 >        } catch (ExecutionException success) {
1597 >        } catch (Exception ex) {
1598              unexpectedException();
1599          } finally {
1600              joinPool(e);
# Line 1612 | Line 1612 | public class ThreadPoolExecutorSubclassT
1612              l.add(new StringTask());
1613              List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1614              assertEquals(2, result.size());
1615 <            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1615 >            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1616                  assertSame(TEST_STRING, it.next().get());
1617          } catch (ExecutionException success) {
1618 <        } catch(Exception ex) {
1618 >        } catch (Exception ex) {
1619              unexpectedException();
1620          } finally {
1621              joinPool(e);
# Line 1634 | Line 1634 | public class ThreadPoolExecutorSubclassT
1634              l.add(new StringTask());
1635              List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
1636              assertEquals(3, result.size());
1637 <            Iterator<Future<String>> it = result.iterator();
1637 >            Iterator<Future<String>> it = result.iterator();
1638              Future<String> f1 = it.next();
1639              Future<String> f2 = it.next();
1640              Future<String> f3 = it.next();
# Line 1643 | Line 1643 | public class ThreadPoolExecutorSubclassT
1643              assertTrue(f3.isDone());
1644              assertFalse(f1.isCancelled());
1645              assertTrue(f2.isCancelled());
1646 <        } catch(Exception ex) {
1646 >        } catch (Exception ex) {
1647              unexpectedException();
1648          } finally {
1649              joinPool(e);
# Line 1662 | Line 1662 | public class ThreadPoolExecutorSubclassT
1662                  e.execute(new NoOpRunnable());
1663              }
1664              Thread.sleep(LONG_DELAY_MS);
1665 <        } catch(Exception ex) {
1665 >        } catch (Exception ex) {
1666              unexpectedException();
1667          } finally {
1668              joinPool(e);
# Line 1688 | Line 1688 | public class ThreadPoolExecutorSubclassT
1688          try {
1689              Thread.sleep(MEDIUM_DELAY_MS);
1690              assertEquals(0, tpe.getPoolSize());
1691 <        } catch(InterruptedException e){
1691 >        } catch (InterruptedException e){
1692              unexpectedException();
1693          } finally {
1694              joinPool(tpe);
# Line 1705 | Line 1705 | public class ThreadPoolExecutorSubclassT
1705          try {
1706              Thread.sleep(MEDIUM_DELAY_MS);
1707              assertTrue(tpe.getPoolSize() >= 1);
1708 <        } catch(InterruptedException e){
1708 >        } catch (InterruptedException e){
1709              unexpectedException();
1710          } finally {
1711              joinPool(tpe);

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines