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.7 by jsr166, Fri Nov 20 16:02:10 2009 UTC vs.
Revision 1.10 by jsr166, Sat Nov 21 17:38:05 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 14 | Line 15 | import java.util.*;
15  
16   public class ThreadPoolExecutorSubclassTest extends JSR166TestCase {
17      public static void main(String[] args) {
18 <        junit.textui.TestRunner.run(suite());
18 >        junit.textui.TestRunner.run(suite());
19      }
20      public static Test suite() {
21          return new TestSuite(ThreadPoolExecutorSubclassTest.class);
# 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);
201 >            Thread.sleep(SMALL_DELAY_MS);
202          } finally {
203              joinPool(p1);
204          }
# 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());
411 >        assertTrue(p1.isShutdown());
412          joinPool(p1);
413      }
414  
# 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 530 | Line 531 | public class ThreadPoolExecutorSubclassT
531              } catch (SecurityException ok) { return; }
532  
533          }
534 <        assertTrue(p1.isShutdown());
535 <        assertTrue(l.size() <= 4);
534 >        assertTrue(p1.isShutdown());
535 >        assertTrue(l.size() <= 4);
536      }
537  
538      // Exception Tests
# 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());
927 <            shouldThrow();
928 <        } catch (RejectedExecutionException success) {}
925 >        try {
926 >            tpe.execute(new NoOpRunnable());
927 >            shouldThrow();
928 >        } catch (RejectedExecutionException success) {}
929  
930 <        joinPool(tpe);
930 >        joinPool(tpe);
931      }
932  
933      /**
# 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 {
941 >        try {
942              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
943 <            p.execute(r);
943 >            p.execute(r);
944              assertFalse(r.done);
945          } finally {
946              joinPool(p);
# 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 {
958 >        try {
959              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
960 <            p.execute(r);
960 >            p.execute(r);
961              assertFalse(r.done);
962          } finally {
963              joinPool(p);
# 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 {
976 >        try {
977              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
978 <            p.execute(r);
978 >            p.execute(r);
979              assertFalse(r.done);
980          } finally {
981              joinPool(p);
# 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));
993 <            tpe.execute(null);
992 >            tpe = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
993 >            tpe.execute(null);
994              shouldThrow();
995 <        } catch (NullPointerException success) {}
995 >        } catch (NullPointerException success) {}
996  
997 <        joinPool(tpe);
997 >        joinPool(tpe);
998      }
999  
1000      /**
1001       *  setCorePoolSize of negative value throws IllegalArgumentException
1002       */
1003      public void testCorePoolSizeIllegalArgumentException() {
1004 <        ThreadPoolExecutor tpe =
1005 <            new CustomTPE(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1006 <        try {
1007 <            tpe.setCorePoolSize(-1);
1008 <            shouldThrow();
1009 <        } catch (IllegalArgumentException success) {
1004 >        ThreadPoolExecutor tpe =
1005 >            new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1006 >        try {
1007 >            tpe.setCorePoolSize(-1);
1008 >            shouldThrow();
1009 >        } catch (IllegalArgumentException success) {
1010          } finally {
1011              try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1012          }
# 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);
1059 >        try {
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());
# Line 1215 | Line 1210 | public class ThreadPoolExecutorSubclassT
1210       * invokeAny(c) returns result of some task
1211       */
1212      public void testInvokeAny5() throws Exception {
1213 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1213 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1214          try {
1215              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1216              l.add(new StringTask());
# Line 1231 | Line 1226 | public class ThreadPoolExecutorSubclassT
1226       * invokeAll(null) throws NPE
1227       */
1228      public void testInvokeAll1() throws Exception {
1229 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1229 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1230          try {
1231              e.invokeAll(null);
1232              shouldThrow();
# Line 1245 | Line 1240 | public class ThreadPoolExecutorSubclassT
1240       * invokeAll(empty collection) returns empty collection
1241       */
1242      public void testInvokeAll2() throws Exception {
1243 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1243 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1244          try {
1245              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1246              assertTrue(r.isEmpty());
# Line 1258 | Line 1253 | public class ThreadPoolExecutorSubclassT
1253       * invokeAll(c) throws NPE if c has null elements
1254       */
1255      public void testInvokeAll3() throws Exception {
1256 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1256 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1257          try {
1258              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1259              l.add(new StringTask());
# Line 1275 | Line 1270 | public class ThreadPoolExecutorSubclassT
1270       * get of element of invokeAll(c) throws exception on failed task
1271       */
1272      public void testInvokeAll4() throws Exception {
1273 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1273 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1274          try {
1275              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1276              l.add(new NPETask());
# Line 1294 | Line 1289 | public class ThreadPoolExecutorSubclassT
1289       * invokeAll(c) returns results of all completed tasks
1290       */
1291      public void testInvokeAll5() throws Exception {
1292 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1292 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1293          try {
1294              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1295              l.add(new StringTask());
# Line 1314 | Line 1309 | public class ThreadPoolExecutorSubclassT
1309       * timed invokeAny(null) throws NPE
1310       */
1311      public void testTimedInvokeAny1() throws Exception {
1312 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1312 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1313          try {
1314 <            e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1314 >            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1315              shouldThrow();
1316          } catch (NullPointerException success) {
1317          } finally {
# Line 1328 | Line 1323 | public class ThreadPoolExecutorSubclassT
1323       * timed invokeAny(,,null) throws NPE
1324       */
1325      public void testTimedInvokeAnyNullTimeUnit() throws Exception {
1326 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1326 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1327          try {
1328              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1329              l.add(new StringTask());
# Line 1344 | Line 1339 | public class ThreadPoolExecutorSubclassT
1339       * timed invokeAny(empty collection) throws IAE
1340       */
1341      public void testTimedInvokeAny2() throws Exception {
1342 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1342 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1343          try {
1344 <            e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1344 >            e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1345              shouldThrow();
1346          } catch (IllegalArgumentException success) {
1347          } finally {
# Line 1358 | Line 1353 | public class ThreadPoolExecutorSubclassT
1353       * timed invokeAny(c) throws NPE if c has null elements
1354       */
1355      public void testTimedInvokeAny3() throws Exception {
1356 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1356 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1357          try {
1358              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1359              l.add(new StringTask());
1360              l.add(null);
1361 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1361 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1362              shouldThrow();
1363          } catch (NullPointerException success) {
1364          } finally {
# Line 1375 | Line 1370 | public class ThreadPoolExecutorSubclassT
1370       * timed invokeAny(c) throws ExecutionException if no task completes
1371       */
1372      public void testTimedInvokeAny4() throws Exception {
1373 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1373 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1374          try {
1375              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1376              l.add(new NPETask());
1377 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1377 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1378              shouldThrow();
1379          } catch (ExecutionException success) {
1380          } finally {
# Line 1391 | Line 1386 | public class ThreadPoolExecutorSubclassT
1386       * timed invokeAny(c) returns result of some task
1387       */
1388      public void testTimedInvokeAny5() throws Exception {
1389 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1389 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1390          try {
1391              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1392              l.add(new StringTask());
1393              l.add(new StringTask());
1394 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1394 >            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1395              assertSame(TEST_STRING, result);
1396          } finally {
1397              joinPool(e);
# Line 1407 | Line 1402 | public class ThreadPoolExecutorSubclassT
1402       * timed invokeAll(null) throws NPE
1403       */
1404      public void testTimedInvokeAll1() throws Exception {
1405 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1405 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1406          try {
1407 <            e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1407 >            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1408              shouldThrow();
1409          } catch (NullPointerException success) {
1410          } finally {
# Line 1421 | Line 1416 | public class ThreadPoolExecutorSubclassT
1416       * timed invokeAll(,,null) throws NPE
1417       */
1418      public void testTimedInvokeAllNullTimeUnit() throws Exception {
1419 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1419 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1420          try {
1421              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1422              l.add(new StringTask());
# Line 1437 | Line 1432 | public class ThreadPoolExecutorSubclassT
1432       * timed invokeAll(empty collection) returns empty collection
1433       */
1434      public void testTimedInvokeAll2() throws Exception {
1435 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1435 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1436          try {
1437 <            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1437 >            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1438              assertTrue(r.isEmpty());
1439          } finally {
1440              joinPool(e);
# Line 1450 | Line 1445 | public class ThreadPoolExecutorSubclassT
1445       * timed invokeAll(c) throws NPE if c has null elements
1446       */
1447      public void testTimedInvokeAll3() throws Exception {
1448 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1448 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1449          try {
1450              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1451              l.add(new StringTask());
1452              l.add(null);
1453 <            e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1453 >            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1454              shouldThrow();
1455          } catch (NullPointerException success) {
1456          } finally {
# Line 1467 | Line 1462 | public class ThreadPoolExecutorSubclassT
1462       * get of element of invokeAll(c) throws exception on failed task
1463       */
1464      public void testTimedInvokeAll4() throws Exception {
1465 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1465 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1466          try {
1467              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1468              l.add(new NPETask());
1469 <            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1469 >            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1470              assertEquals(1, result.size());
1471              for (Future<String> future : result)
1472                  future.get();
# Line 1487 | Line 1482 | public class ThreadPoolExecutorSubclassT
1482       * timed invokeAll(c) returns results of all completed tasks
1483       */
1484      public void testTimedInvokeAll5() throws Exception {
1485 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1485 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1486          try {
1487              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1488              l.add(new StringTask());
1489              l.add(new StringTask());
1490 <            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
1490 >            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1491              assertEquals(2, result.size());
1492              for (Future<String> future : result)
1493                  assertSame(TEST_STRING, future.get());
# Line 1506 | Line 1501 | public class ThreadPoolExecutorSubclassT
1501       * timed invokeAll(c) cancels tasks not completed by timeout
1502       */
1503      public void testTimedInvokeAll6() throws Exception {
1504 <        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1504 >        ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1505          try {
1506              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1507              l.add(new StringTask());
1508              l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1509              l.add(new StringTask());
1510 <            List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
1510 >            List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1511              assertEquals(3, result.size());
1512              Iterator<Future<String>> it = result.iterator();
1513              Future<String> f1 = it.next();
# Line 1533 | Line 1528 | public class ThreadPoolExecutorSubclassT
1528       * thread factory fails to create more
1529       */
1530      public void testFailingThreadFactory() throws InterruptedException {
1531 <        ExecutorService e = new CustomTPE(100, 100, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory());
1531 >        ExecutorService e = new CustomTPE(100, 100, LONG_DELAY_MS, MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory());
1532          try {
1533              for (int k = 0; k < 100; ++k) {
1534                  e.execute(new NoOpRunnable());
# Line 1548 | Line 1543 | public class ThreadPoolExecutorSubclassT
1543       * allowsCoreThreadTimeOut is by default false.
1544       */
1545      public void testAllowsCoreThreadTimeOut() {
1546 <        ThreadPoolExecutor tpe = new CustomTPE(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1546 >        ThreadPoolExecutor tpe = new CustomTPE(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1547          assertFalse(tpe.allowsCoreThreadTimeOut());
1548          joinPool(tpe);
1549      }
# Line 1557 | Line 1552 | public class ThreadPoolExecutorSubclassT
1552       * allowCoreThreadTimeOut(true) causes idle threads to time out
1553       */
1554      public void testAllowCoreThreadTimeOut_true() throws InterruptedException {
1555 <        ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1555 >        ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1556          tpe.allowCoreThreadTimeOut(true);
1557          tpe.execute(new NoOpRunnable());
1558          try {
# Line 1572 | Line 1567 | public class ThreadPoolExecutorSubclassT
1567       * allowCoreThreadTimeOut(false) causes idle threads not to time out
1568       */
1569      public void testAllowCoreThreadTimeOut_false() throws InterruptedException {
1570 <        ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1570 >        ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1571          tpe.allowCoreThreadTimeOut(false);
1572          tpe.execute(new NoOpRunnable());
1573          try {

Diff Legend

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