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.8 by jsr166, Sat Nov 21 02:07:27 2009 UTC vs.
Revision 1.14 by jsr166, Sat Nov 21 20:13:20 2009 UTC

# Line 7 | Line 7
7   */
8  
9   import java.util.concurrent.*;
10 + import static java.util.concurrent.TimeUnit.MILLISECONDS;
11   import java.util.concurrent.locks.*;
12  
13   import junit.framework.*;
# Line 167 | Line 168 | public class ThreadPoolExecutorSubclassT
168          volatile boolean afterCalled = false;
169          volatile boolean terminatedCalled = false;
170          public CustomTPE() {
171 <            super(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());
171 >            super(1, 1, LONG_DELAY_MS, MILLISECONDS, new SynchronousQueue<Runnable>());
172          }
173          protected void beforeExecute(Thread t, Runnable r) {
174              beforeCalled = true;
# Line 194 | Line 195 | public class ThreadPoolExecutorSubclassT
195       *  execute successfully executes a runnable
196       */
197      public void testExecute() throws InterruptedException {
198 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
198 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
199          try {
200              p1.execute(new ShortRunnable());
201              Thread.sleep(SMALL_DELAY_MS);
# Line 208 | Line 209 | public class ThreadPoolExecutorSubclassT
209       *  thread becomes active
210       */
211      public void testGetActiveCount() throws InterruptedException {
212 <        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
212 >        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
213          assertEquals(0, p2.getActiveCount());
214          p2.execute(new MediumRunnable());
215          Thread.sleep(SHORT_DELAY_MS);
# Line 220 | Line 221 | public class ThreadPoolExecutorSubclassT
221       *  prestartCoreThread starts a thread if under corePoolSize, else doesn't
222       */
223      public void testPrestartCoreThread() {
224 <        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
224 >        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
225          assertEquals(0, p2.getPoolSize());
226          assertTrue(p2.prestartCoreThread());
227          assertEquals(1, p2.getPoolSize());
# Line 235 | Line 236 | public class ThreadPoolExecutorSubclassT
236       *  prestartAllCoreThreads starts all corePoolSize threads
237       */
238      public void testPrestartAllCoreThreads() {
239 <        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
239 >        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
240          assertEquals(0, p2.getPoolSize());
241          p2.prestartAllCoreThreads();
242          assertEquals(2, p2.getPoolSize());
# Line 249 | Line 250 | public class ThreadPoolExecutorSubclassT
250       *   when tasks complete
251       */
252      public void testGetCompletedTaskCount() throws InterruptedException {
253 <        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
253 >        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
254          assertEquals(0, p2.getCompletedTaskCount());
255          p2.execute(new ShortRunnable());
256          Thread.sleep(SMALL_DELAY_MS);
# Line 262 | Line 263 | public class ThreadPoolExecutorSubclassT
263       *   getCorePoolSize returns size given in constructor if not otherwise set
264       */
265      public void testGetCorePoolSize() {
266 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
266 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
267          assertEquals(1, p1.getCorePoolSize());
268          joinPool(p1);
269      }
# Line 271 | Line 272 | public class ThreadPoolExecutorSubclassT
272       *   getKeepAliveTime returns value given in constructor if not otherwise set
273       */
274      public void testGetKeepAliveTime() {
275 <        ThreadPoolExecutor p2 = new CustomTPE(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
275 >        ThreadPoolExecutor p2 = new CustomTPE(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
276          assertEquals(1, p2.getKeepAliveTime(TimeUnit.SECONDS));
277          joinPool(p2);
278      }
# Line 282 | Line 283 | public class ThreadPoolExecutorSubclassT
283       */
284      public void testGetThreadFactory() {
285          ThreadFactory tf = new SimpleThreadFactory();
286 <        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler());
286 >        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler());
287          assertSame(tf, p.getThreadFactory());
288          joinPool(p);
289      }
# Line 291 | Line 292 | public class ThreadPoolExecutorSubclassT
292       * setThreadFactory sets the thread factory returned by getThreadFactory
293       */
294      public void testSetThreadFactory() {
295 <        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
295 >        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
296          ThreadFactory tf = new SimpleThreadFactory();
297          p.setThreadFactory(tf);
298          assertSame(tf, p.getThreadFactory());
# Line 303 | Line 304 | public class ThreadPoolExecutorSubclassT
304       * setThreadFactory(null) throws NPE
305       */
306      public void testSetThreadFactoryNull() {
307 <        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
307 >        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
308          try {
309              p.setThreadFactory(null);
310              shouldThrow();
# Line 318 | Line 319 | public class ThreadPoolExecutorSubclassT
319       */
320      public void testGetRejectedExecutionHandler() {
321          RejectedExecutionHandler h = new NoOpREHandler();
322 <        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h);
322 >        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h);
323          assertSame(h, p.getRejectedExecutionHandler());
324          joinPool(p);
325      }
# Line 328 | Line 329 | public class ThreadPoolExecutorSubclassT
329       * getRejectedExecutionHandler
330       */
331      public void testSetRejectedExecutionHandler() {
332 <        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
332 >        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
333          RejectedExecutionHandler h = new NoOpREHandler();
334          p.setRejectedExecutionHandler(h);
335          assertSame(h, p.getRejectedExecutionHandler());
# Line 340 | Line 341 | public class ThreadPoolExecutorSubclassT
341       * setRejectedExecutionHandler(null) throws NPE
342       */
343      public void testSetRejectedExecutionHandlerNull() {
344 <        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
344 >        ThreadPoolExecutor p = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
345          try {
346              p.setRejectedExecutionHandler(null);
347              shouldThrow();
# Line 356 | Line 357 | public class ThreadPoolExecutorSubclassT
357       *   multiple threads active
358       */
359      public void testGetLargestPoolSize() throws InterruptedException {
360 <        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
360 >        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
361          assertEquals(0, p2.getLargestPoolSize());
362          p2.execute(new MediumRunnable());
363          p2.execute(new MediumRunnable());
# Line 370 | Line 371 | public class ThreadPoolExecutorSubclassT
371       *   otherwise set
372       */
373      public void testGetMaximumPoolSize() {
374 <        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
374 >        ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
375          assertEquals(2, p2.getMaximumPoolSize());
376          joinPool(p2);
377      }
# Line 380 | Line 381 | public class ThreadPoolExecutorSubclassT
381       *   become active
382       */
383      public void testGetPoolSize() {
384 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
384 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
385          assertEquals(0, p1.getPoolSize());
386          p1.execute(new MediumRunnable());
387          assertEquals(1, p1.getPoolSize());
# Line 391 | Line 392 | public class ThreadPoolExecutorSubclassT
392       *  getTaskCount increases, but doesn't overestimate, when tasks submitted
393       */
394      public void testGetTaskCount() throws InterruptedException {
395 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
395 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
396          assertEquals(0, p1.getTaskCount());
397          p1.execute(new MediumRunnable());
398          Thread.sleep(SHORT_DELAY_MS);
# Line 404 | Line 405 | public class ThreadPoolExecutorSubclassT
405       */
406      public void testIsShutdown() {
407  
408 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
408 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
409          assertFalse(p1.isShutdown());
410          try { p1.shutdown(); } catch (SecurityException ok) { return; }
411          assertTrue(p1.isShutdown());
# Line 416 | Line 417 | public class ThreadPoolExecutorSubclassT
417       *  isTerminated is false before termination, true after
418       */
419      public void testIsTerminated() throws InterruptedException {
420 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
420 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
421          assertFalse(p1.isTerminated());
422          try {
423              p1.execute(new MediumRunnable());
424          } finally {
425              try { p1.shutdown(); } catch (SecurityException ok) { return; }
426          }
427 <        assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
427 >        assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
428          assertTrue(p1.isTerminated());
429      }
430  
# Line 431 | Line 432 | public class ThreadPoolExecutorSubclassT
432       *  isTerminating is not true when running or when terminated
433       */
434      public void testIsTerminating() throws InterruptedException {
435 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
435 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
436          assertFalse(p1.isTerminating());
437          try {
438              p1.execute(new SmallRunnable());
# Line 439 | Line 440 | public class ThreadPoolExecutorSubclassT
440          } finally {
441              try { p1.shutdown(); } catch (SecurityException ok) { return; }
442          }
443 <        assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
443 >        assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
444          assertTrue(p1.isTerminated());
445          assertFalse(p1.isTerminating());
446      }
# Line 449 | Line 450 | public class ThreadPoolExecutorSubclassT
450       */
451      public void testGetQueue() throws InterruptedException {
452          BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
453 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
453 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, q);
454          FutureTask[] tasks = new FutureTask[5];
455          for (int i = 0; i < 5; i++) {
456              tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
# Line 474 | Line 475 | public class ThreadPoolExecutorSubclassT
475       */
476      public void testRemove() throws InterruptedException {
477          BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
478 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
478 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, q);
479          FutureTask[] tasks = new FutureTask[5];
480          for (int i = 0; i < 5; i++) {
481              tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
# Line 500 | Line 501 | public class ThreadPoolExecutorSubclassT
501       *   purge removes cancelled tasks from the queue
502       */
503      public void testPurge() {
504 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
504 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
505          FutureTask[] tasks = new FutureTask[5];
506          for (int i = 0; i < 5; i++) {
507              tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
# Line 518 | Line 519 | public class ThreadPoolExecutorSubclassT
519       *  shutDownNow returns a list containing tasks that were not run
520       */
521      public void testShutDownNow() {
522 <        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
522 >        ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
523          List l;
524          try {
525              for (int i = 0; i < 5; i++)
# Line 542 | Line 543 | public class ThreadPoolExecutorSubclassT
543       */
544      public void testConstructor1() {
545          try {
546 <            new CustomTPE(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
546 >            new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
547              shouldThrow();
548          } catch (IllegalArgumentException success) {}
549      }
# Line 552 | Line 553 | public class ThreadPoolExecutorSubclassT
553       */
554      public void testConstructor2() {
555          try {
556 <            new CustomTPE(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
556 >            new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
557              shouldThrow();
558          } catch (IllegalArgumentException success) {}
559      }
# Line 562 | Line 563 | public class ThreadPoolExecutorSubclassT
563       */
564      public void testConstructor3() {
565          try {
566 <            new CustomTPE(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
566 >            new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
567              shouldThrow();
568          } catch (IllegalArgumentException success) {}
569      }
# Line 572 | Line 573 | public class ThreadPoolExecutorSubclassT
573       */
574      public void testConstructor4() {
575          try {
576 <            new CustomTPE(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
576 >            new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
577              shouldThrow();
578          } catch (IllegalArgumentException success) {}
579      }
# Line 582 | Line 583 | public class ThreadPoolExecutorSubclassT
583       */
584      public void testConstructor5() {
585          try {
586 <            new CustomTPE(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
586 >            new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
587              shouldThrow();
588          } catch (IllegalArgumentException success) {}
589      }
# Line 592 | Line 593 | public class ThreadPoolExecutorSubclassT
593       */
594      public void testConstructorNullPointerException() {
595          try {
596 <            new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null);
596 >            new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null);
597              shouldThrow();
598          } catch (NullPointerException success) {}
599      }
# Line 604 | Line 605 | public class ThreadPoolExecutorSubclassT
605       */
606      public void testConstructor6() {
607          try {
608 <            new CustomTPE(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
608 >            new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
609              shouldThrow();
610          } catch (IllegalArgumentException success) {}
611      }
# Line 614 | Line 615 | public class ThreadPoolExecutorSubclassT
615       */
616      public void testConstructor7() {
617          try {
618 <            new CustomTPE(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
618 >            new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
619              shouldThrow();
620          } catch (IllegalArgumentException success) {}
621      }
# Line 624 | Line 625 | public class ThreadPoolExecutorSubclassT
625       */
626      public void testConstructor8() {
627          try {
628 <            new CustomTPE(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
628 >            new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
629              shouldThrow();
630          } catch (IllegalArgumentException success) {}
631      }
# Line 634 | Line 635 | public class ThreadPoolExecutorSubclassT
635       */
636      public void testConstructor9() {
637          try {
638 <            new CustomTPE(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
638 >            new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
639              shouldThrow();
640          } catch (IllegalArgumentException success) {}
641      }
# Line 644 | Line 645 | public class ThreadPoolExecutorSubclassT
645       */
646      public void testConstructor10() {
647          try {
648 <            new CustomTPE(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
648 >            new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
649              shouldThrow();
650          } catch (IllegalArgumentException success) {}
651      }
# Line 654 | Line 655 | public class ThreadPoolExecutorSubclassT
655       */
656      public void testConstructorNullPointerException2() {
657          try {
658 <            new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory());
658 >            new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null,new SimpleThreadFactory());
659              shouldThrow();
660          } catch (NullPointerException success) {}
661      }
# Line 665 | Line 666 | public class ThreadPoolExecutorSubclassT
666      public void testConstructorNullPointerException3() {
667          try {
668              ThreadFactory f = null;
669 <            new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
669 >            new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
670              shouldThrow();
671          } catch (NullPointerException success) {}
672      }
# Line 676 | Line 677 | public class ThreadPoolExecutorSubclassT
677       */
678      public void testConstructor11() {
679          try {
680 <            new CustomTPE(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
680 >            new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
681              shouldThrow();
682          } catch (IllegalArgumentException success) {}
683      }
# Line 686 | Line 687 | public class ThreadPoolExecutorSubclassT
687       */
688      public void testConstructor12() {
689          try {
690 <            new CustomTPE(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
690 >            new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
691              shouldThrow();
692          } catch (IllegalArgumentException success) {}
693      }
# Line 696 | Line 697 | public class ThreadPoolExecutorSubclassT
697       */
698      public void testConstructor13() {
699          try {
700 <            new CustomTPE(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
700 >            new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
701              shouldThrow();
702          } catch (IllegalArgumentException success) {}
703      }
# Line 706 | Line 707 | public class ThreadPoolExecutorSubclassT
707       */
708      public void testConstructor14() {
709          try {
710 <            new CustomTPE(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
710 >            new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
711              shouldThrow();
712          } catch (IllegalArgumentException success) {}
713      }
# Line 716 | Line 717 | public class ThreadPoolExecutorSubclassT
717       */
718      public void testConstructor15() {
719          try {
720 <            new CustomTPE(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
720 >            new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
721              shouldThrow();
722          } catch (IllegalArgumentException success) {}
723      }
# Line 726 | Line 727 | public class ThreadPoolExecutorSubclassT
727       */
728      public void testConstructorNullPointerException4() {
729          try {
730 <            new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new NoOpREHandler());
730 >            new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null,new NoOpREHandler());
731              shouldThrow();
732          } catch (NullPointerException success) {}
733      }
# Line 737 | Line 738 | public class ThreadPoolExecutorSubclassT
738      public void testConstructorNullPointerException5() {
739          try {
740              RejectedExecutionHandler r = null;
741 <            new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
741 >            new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
742              shouldThrow();
743          } catch (NullPointerException success) {}
744      }
# Line 748 | Line 749 | public class ThreadPoolExecutorSubclassT
749       */
750      public void testConstructor16() {
751          try {
752 <            new CustomTPE(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
752 >            new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
753              shouldThrow();
754          } catch (IllegalArgumentException success) {}
755      }
# Line 758 | Line 759 | public class ThreadPoolExecutorSubclassT
759       */
760      public void testConstructor17() {
761          try {
762 <            new CustomTPE(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
762 >            new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
763              shouldThrow();
764          } catch (IllegalArgumentException success) {}
765      }
# Line 768 | Line 769 | public class ThreadPoolExecutorSubclassT
769       */
770      public void testConstructor18() {
771          try {
772 <            new CustomTPE(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
772 >            new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
773              shouldThrow();
774          } catch (IllegalArgumentException success) {}
775      }
# Line 778 | Line 779 | public class ThreadPoolExecutorSubclassT
779       */
780      public void testConstructor19() {
781          try {
782 <            new CustomTPE(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
782 >            new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
783              shouldThrow();
784          } catch (IllegalArgumentException success) {}
785      }
# Line 788 | Line 789 | public class ThreadPoolExecutorSubclassT
789       */
790      public void testConstructor20() {
791          try {
792 <            new CustomTPE(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
792 >            new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
793              shouldThrow();
794          } catch (IllegalArgumentException success) {}
795      }
# Line 798 | Line 799 | public class ThreadPoolExecutorSubclassT
799       */
800      public void testConstructorNullPointerException6() {
801          try {
802 <            new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler());
802 >            new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler());
803              shouldThrow();
804          } catch (NullPointerException success) {}
805      }
# Line 809 | Line 810 | public class ThreadPoolExecutorSubclassT
810      public void testConstructorNullPointerException7() {
811          try {
812              RejectedExecutionHandler r = null;
813 <            new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r);
813 >            new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r);
814              shouldThrow();
815          } catch (NullPointerException success) {}
816      }
# Line 820 | Line 821 | public class ThreadPoolExecutorSubclassT
821      public void testConstructorNullPointerException8() {
822          try {
823              ThreadFactory f = null;
824 <            new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler());
824 >            new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler());
825              shouldThrow();
826          } catch (NullPointerException success) {}
827      }
# Line 831 | Line 832 | public class ThreadPoolExecutorSubclassT
832       *  if saturated.
833       */
834      public void testSaturatedExecute() {
835 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
835 >        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
836          try {
837  
838              for (int i = 0; i < 5; ++i) {
# Line 847 | Line 848 | public class ThreadPoolExecutorSubclassT
848       */
849      public void testSaturatedExecute2() {
850          RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy();
851 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
851 >        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
852          try {
853  
854              TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
# Line 873 | Line 874 | public class ThreadPoolExecutorSubclassT
874       */
875      public void testSaturatedExecute3() {
876          RejectedExecutionHandler h = new CustomTPE.DiscardPolicy();
877 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
877 >        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
878          try {
879  
880              TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
# Line 898 | Line 899 | public class ThreadPoolExecutorSubclassT
899       */
900      public void testSaturatedExecute4() {
901          RejectedExecutionHandler h = new CustomTPE.DiscardOldestPolicy();
902 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
902 >        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
903          try {
904              p.execute(new TrackedLongRunnable());
905              TrackedLongRunnable r2 = new TrackedLongRunnable();
# Line 919 | Line 920 | public class ThreadPoolExecutorSubclassT
920       */
921      public void testRejectedExecutionExceptionOnShutdown() {
922          ThreadPoolExecutor tpe =
923 <            new CustomTPE(1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
923 >            new CustomTPE(1,1,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
924          try { tpe.shutdown(); } catch (SecurityException ok) { return; }
925          try {
926              tpe.execute(new NoOpRunnable());
# Line 934 | Line 935 | public class ThreadPoolExecutorSubclassT
935       */
936      public void testCallerRunsOnShutdown() {
937          RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy();
938 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
938 >        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
939  
940          try { p.shutdown(); } catch (SecurityException ok) { return; }
941          try {
# Line 951 | Line 952 | public class ThreadPoolExecutorSubclassT
952       */
953      public void testDiscardOnShutdown() {
954          RejectedExecutionHandler h = new CustomTPE.DiscardPolicy();
955 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
955 >        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
956  
957          try { p.shutdown(); } catch (SecurityException ok) { return; }
958          try {
# Line 969 | Line 970 | public class ThreadPoolExecutorSubclassT
970       */
971      public void testDiscardOldestOnShutdown() {
972          RejectedExecutionHandler h = new CustomTPE.DiscardOldestPolicy();
973 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
973 >        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
974  
975          try { p.shutdown(); } catch (SecurityException ok) { return; }
976          try {
# Line 988 | Line 989 | public class ThreadPoolExecutorSubclassT
989      public void testExecuteNull() {
990          ThreadPoolExecutor tpe = null;
991          try {
992 <            tpe = new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
992 >            tpe = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
993              tpe.execute(null);
994              shouldThrow();
995          } catch (NullPointerException success) {}
# Line 1001 | Line 1002 | public class ThreadPoolExecutorSubclassT
1002       */
1003      public void testCorePoolSizeIllegalArgumentException() {
1004          ThreadPoolExecutor tpe =
1005 <            new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1005 >            new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1006          try {
1007              tpe.setCorePoolSize(-1);
1008              shouldThrow();
# Line 1017 | Line 1018 | public class ThreadPoolExecutorSubclassT
1018       *  given a value less the core pool size
1019       */
1020      public void testMaximumPoolSizeIllegalArgumentException() {
1021 <        ThreadPoolExecutor tpe = null;
1022 <        try {
1022 <            tpe = new CustomTPE(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1023 <        } catch (Exception e) {}
1021 >        ThreadPoolExecutor tpe =
1022 >            new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1023          try {
1024              tpe.setMaximumPoolSize(1);
1025              shouldThrow();
# Line 1036 | Line 1035 | public class ThreadPoolExecutorSubclassT
1035       *  if given a negative value
1036       */
1037      public void testMaximumPoolSizeIllegalArgumentException2() {
1038 <        ThreadPoolExecutor tpe = null;
1039 <        try {
1041 <            tpe = new CustomTPE(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1042 <        } catch (Exception e) {}
1038 >        ThreadPoolExecutor tpe =
1039 >            new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1040          try {
1041              tpe.setMaximumPoolSize(-1);
1042              shouldThrow();
# Line 1056 | Line 1053 | public class ThreadPoolExecutorSubclassT
1053       *  when given a negative value
1054       */
1055      public void testKeepAliveTimeIllegalArgumentException() {
1056 <        ThreadPoolExecutor tpe = null;
1057 <        try {
1061 <            tpe = new CustomTPE(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1062 <        } catch (Exception e) {}
1056 >        ThreadPoolExecutor tpe =
1057 >            new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1058  
1059          try {
1060 <            tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS);
1060 >            tpe.setKeepAliveTime(-1,MILLISECONDS);
1061              shouldThrow();
1062          } catch (IllegalArgumentException success) {
1063          } finally {
# Line 1103 | Line 1098 | public class ThreadPoolExecutorSubclassT
1098       * completed submit of callable returns result
1099       */
1100      public void testSubmitCallable() throws Exception {
1101 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1101 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1102          try {
1103              Future<String> future = e.submit(new StringTask());
1104              String result = future.get();
# Line 1117 | Line 1112 | public class ThreadPoolExecutorSubclassT
1112       * completed submit of runnable returns successfully
1113       */
1114      public void testSubmitRunnable() throws Exception {
1115 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1115 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1116          try {
1117              Future<?> future = e.submit(new NoOpRunnable());
1118              future.get();
# Line 1131 | Line 1126 | public class ThreadPoolExecutorSubclassT
1126       * completed submit of (runnable, result) returns result
1127       */
1128      public void testSubmitRunnable2() throws Exception {
1129 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1129 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1130          try {
1131              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
1132              String result = future.get();
# Line 1146 | Line 1141 | public class ThreadPoolExecutorSubclassT
1141       * invokeAny(null) throws NPE
1142       */
1143      public void testInvokeAny1() throws Exception {
1144 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1144 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1145          try {
1146              e.invokeAny(null);
1147              shouldThrow();
# Line 1160 | Line 1155 | public class ThreadPoolExecutorSubclassT
1155       * invokeAny(empty collection) throws IAE
1156       */
1157      public void testInvokeAny2() throws Exception {
1158 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1158 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1159          try {
1160              e.invokeAny(new ArrayList<Callable<String>>());
1161              shouldThrow();
# Line 1175 | Line 1170 | public class ThreadPoolExecutorSubclassT
1170       */
1171      public void testInvokeAny3() throws Exception {
1172          final CountDownLatch latch = new CountDownLatch(1);
1173 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1173 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1174          try {
1175              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1176              l.add(new Callable<String>() {
# Line 1199 | Line 1194 | public class ThreadPoolExecutorSubclassT
1194       * invokeAny(c) throws ExecutionException if no task completes
1195       */
1196      public void testInvokeAny4() throws Exception {
1197 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1197 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1198          try {
1199              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1200              l.add(new NPETask());
1201              e.invokeAny(l);
1202              shouldThrow();
1203          } catch (ExecutionException success) {
1204 +            assertTrue(success.getCause() instanceof NullPointerException);
1205          } finally {
1206              joinPool(e);
1207          }
# Line 1215 | Line 1211 | public class ThreadPoolExecutorSubclassT
1211       * invokeAny(c) returns result of some task
1212       */
1213      public void testInvokeAny5() throws Exception {
1214 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1214 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1215          try {
1216              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1217              l.add(new StringTask());
# Line 1231 | Line 1227 | public class ThreadPoolExecutorSubclassT
1227       * invokeAll(null) throws NPE
1228       */
1229      public void testInvokeAll1() throws Exception {
1230 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1230 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1231          try {
1232              e.invokeAll(null);
1233              shouldThrow();
# Line 1245 | Line 1241 | public class ThreadPoolExecutorSubclassT
1241       * invokeAll(empty collection) returns empty collection
1242       */
1243      public void testInvokeAll2() throws Exception {
1244 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1244 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1245          try {
1246              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1247              assertTrue(r.isEmpty());
# Line 1258 | Line 1254 | public class ThreadPoolExecutorSubclassT
1254       * invokeAll(c) throws NPE if c has null elements
1255       */
1256      public void testInvokeAll3() throws Exception {
1257 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1257 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1258          try {
1259              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1260              l.add(new StringTask());
# Line 1275 | Line 1271 | public class ThreadPoolExecutorSubclassT
1271       * get of element of invokeAll(c) throws exception on failed task
1272       */
1273      public void testInvokeAll4() throws Exception {
1274 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1274 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1275          try {
1276              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1277              l.add(new NPETask());
# Line 1294 | Line 1290 | public class ThreadPoolExecutorSubclassT
1290       * invokeAll(c) returns results of all completed tasks
1291       */
1292      public void testInvokeAll5() throws Exception {
1293 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1293 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1294          try {
1295              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1296              l.add(new StringTask());
# Line 1314 | Line 1310 | public class ThreadPoolExecutorSubclassT
1310       * timed invokeAny(null) throws NPE
1311       */
1312      public void testTimedInvokeAny1() throws Exception {
1313 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1313 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1314          try {
1315 <            e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1315 >            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1316              shouldThrow();
1317          } catch (NullPointerException success) {
1318          } finally {
# Line 1328 | Line 1324 | public class ThreadPoolExecutorSubclassT
1324       * timed invokeAny(,,null) throws NPE
1325       */
1326      public void testTimedInvokeAnyNullTimeUnit() throws Exception {
1327 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1327 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1328          try {
1329              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1330              l.add(new StringTask());
# Line 1344 | Line 1340 | public class ThreadPoolExecutorSubclassT
1340       * timed invokeAny(empty collection) throws IAE
1341       */
1342      public void testTimedInvokeAny2() throws Exception {
1343 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1343 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1344          try {
1345 <            e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1345 >            e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1346              shouldThrow();
1347          } catch (IllegalArgumentException success) {
1348          } finally {
# Line 1358 | Line 1354 | public class ThreadPoolExecutorSubclassT
1354       * timed invokeAny(c) throws NPE if c has null elements
1355       */
1356      public void testTimedInvokeAny3() throws Exception {
1357 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1357 >        final CountDownLatch latch = new CountDownLatch(1);
1358 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1359          try {
1360              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1361 <            l.add(new StringTask());
1361 >            l.add(new Callable<String>() {
1362 >                      public String call() {
1363 >                          try {
1364 >                              latch.await();
1365 >                          } catch (InterruptedException ok) {}
1366 >                          return TEST_STRING;
1367 >                      }});
1368              l.add(null);
1369 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1369 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1370              shouldThrow();
1371          } catch (NullPointerException success) {
1372          } finally {
1373 +            latch.countDown();
1374              joinPool(e);
1375          }
1376      }
# Line 1375 | Line 1379 | public class ThreadPoolExecutorSubclassT
1379       * timed invokeAny(c) throws ExecutionException if no task completes
1380       */
1381      public void testTimedInvokeAny4() throws Exception {
1382 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1382 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1383          try {
1384              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1385              l.add(new NPETask());
1386 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1386 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1387              shouldThrow();
1388          } catch (ExecutionException success) {
1389 +            assertTrue(success.getCause() instanceof NullPointerException);
1390          } finally {
1391              joinPool(e);
1392          }
# Line 1391 | Line 1396 | public class ThreadPoolExecutorSubclassT
1396       * timed invokeAny(c) returns result of some task
1397       */
1398      public void testTimedInvokeAny5() throws Exception {
1399 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1399 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1400          try {
1401              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1402              l.add(new StringTask());
1403              l.add(new StringTask());
1404 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1404 >            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1405              assertSame(TEST_STRING, result);
1406          } finally {
1407              joinPool(e);
# Line 1407 | Line 1412 | public class ThreadPoolExecutorSubclassT
1412       * timed invokeAll(null) throws NPE
1413       */
1414      public void testTimedInvokeAll1() throws Exception {
1415 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1415 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1416          try {
1417 <            e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1417 >            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1418              shouldThrow();
1419          } catch (NullPointerException success) {
1420          } finally {
# Line 1421 | Line 1426 | public class ThreadPoolExecutorSubclassT
1426       * timed invokeAll(,,null) throws NPE
1427       */
1428      public void testTimedInvokeAllNullTimeUnit() throws Exception {
1429 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1429 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1430          try {
1431              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1432              l.add(new StringTask());
# Line 1437 | Line 1442 | public class ThreadPoolExecutorSubclassT
1442       * timed invokeAll(empty collection) returns empty collection
1443       */
1444      public void testTimedInvokeAll2() throws Exception {
1445 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1445 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1446          try {
1447 <            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1447 >            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1448              assertTrue(r.isEmpty());
1449          } finally {
1450              joinPool(e);
# Line 1450 | Line 1455 | public class ThreadPoolExecutorSubclassT
1455       * timed invokeAll(c) throws NPE if c has null elements
1456       */
1457      public void testTimedInvokeAll3() throws Exception {
1458 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1458 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1459          try {
1460              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1461              l.add(new StringTask());
1462              l.add(null);
1463 <            e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1463 >            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1464              shouldThrow();
1465          } catch (NullPointerException success) {
1466          } finally {
# Line 1467 | Line 1472 | public class ThreadPoolExecutorSubclassT
1472       * get of element of invokeAll(c) throws exception on failed task
1473       */
1474      public void testTimedInvokeAll4() throws Exception {
1475 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1475 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1476          try {
1477              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1478              l.add(new NPETask());
1479 <            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1479 >            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1480              assertEquals(1, result.size());
1481              for (Future<String> future : result)
1482                  future.get();
# Line 1487 | Line 1492 | public class ThreadPoolExecutorSubclassT
1492       * timed invokeAll(c) returns results of all completed tasks
1493       */
1494      public void testTimedInvokeAll5() throws Exception {
1495 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1495 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1496          try {
1497              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1498              l.add(new StringTask());
1499              l.add(new StringTask());
1500 <            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1500 >            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1501              assertEquals(2, result.size());
1502              for (Future<String> future : result)
1503                  assertSame(TEST_STRING, future.get());
1499 –        } catch (ExecutionException success) {
1504          } finally {
1505              joinPool(e);
1506          }
# Line 1506 | Line 1510 | public class ThreadPoolExecutorSubclassT
1510       * timed invokeAll(c) cancels tasks not completed by timeout
1511       */
1512      public void testTimedInvokeAll6() throws Exception {
1513 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1513 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1514          try {
1515              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1516              l.add(new StringTask());
1517              l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1518              l.add(new StringTask());
1519 <            List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
1519 >            List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1520              assertEquals(3, result.size());
1521              Iterator<Future<String>> it = result.iterator();
1522              Future<String> f1 = it.next();
# Line 1533 | Line 1537 | public class ThreadPoolExecutorSubclassT
1537       * thread factory fails to create more
1538       */
1539      public void testFailingThreadFactory() throws InterruptedException {
1540 <        ExecutorService e = new CustomTPE(100, 100, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory());
1540 >        ExecutorService e = new CustomTPE(100, 100, LONG_DELAY_MS, MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory());
1541          try {
1542              for (int k = 0; k < 100; ++k) {
1543                  e.execute(new NoOpRunnable());
# Line 1548 | Line 1552 | public class ThreadPoolExecutorSubclassT
1552       * allowsCoreThreadTimeOut is by default false.
1553       */
1554      public void testAllowsCoreThreadTimeOut() {
1555 <        ThreadPoolExecutor tpe = new CustomTPE(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1555 >        ThreadPoolExecutor tpe = new CustomTPE(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1556          assertFalse(tpe.allowsCoreThreadTimeOut());
1557          joinPool(tpe);
1558      }
# Line 1557 | Line 1561 | public class ThreadPoolExecutorSubclassT
1561       * allowCoreThreadTimeOut(true) causes idle threads to time out
1562       */
1563      public void testAllowCoreThreadTimeOut_true() throws InterruptedException {
1564 <        ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1564 >        ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1565          tpe.allowCoreThreadTimeOut(true);
1566          tpe.execute(new NoOpRunnable());
1567          try {
# Line 1572 | Line 1576 | public class ThreadPoolExecutorSubclassT
1576       * allowCoreThreadTimeOut(false) causes idle threads not to time out
1577       */
1578      public void testAllowCoreThreadTimeOut_false() throws InterruptedException {
1579 <        ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1579 >        ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1580          tpe.allowCoreThreadTimeOut(false);
1581          tpe.execute(new NoOpRunnable());
1582          try {

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines