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

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.37 by jsr166, Mon Oct 11 07:21:32 2010 UTC vs.
Revision 1.68 by jsr166, Sun Oct 4 01:27:32 2015 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import java.util.concurrent.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 < import java.util.concurrent.atomic.*;
11 < import junit.framework.*;
12 < import java.util.*;
10 > import static java.util.concurrent.TimeUnit.NANOSECONDS;
11 > import static java.util.concurrent.TimeUnit.SECONDS;
12 >
13 > import java.util.ArrayList;
14 > import java.util.List;
15 > import java.util.concurrent.ArrayBlockingQueue;
16 > import java.util.concurrent.BlockingQueue;
17 > import java.util.concurrent.Callable;
18 > import java.util.concurrent.CancellationException;
19 > import java.util.concurrent.CountDownLatch;
20 > import java.util.concurrent.ExecutionException;
21 > import java.util.concurrent.Executors;
22 > import java.util.concurrent.ExecutorService;
23 > import java.util.concurrent.Future;
24 > import java.util.concurrent.FutureTask;
25 > import java.util.concurrent.LinkedBlockingQueue;
26 > import java.util.concurrent.RejectedExecutionException;
27 > import java.util.concurrent.RejectedExecutionHandler;
28 > import java.util.concurrent.SynchronousQueue;
29 > import java.util.concurrent.ThreadFactory;
30 > import java.util.concurrent.ThreadPoolExecutor;
31 > import java.util.concurrent.TimeUnit;
32 > import java.util.concurrent.atomic.AtomicInteger;
33 >
34 > import junit.framework.Test;
35 > import junit.framework.TestSuite;
36  
37   public class ThreadPoolExecutorTest extends JSR166TestCase {
38      public static void main(String[] args) {
39 <        junit.textui.TestRunner.run(suite());
39 >        main(suite(), args);
40      }
41      public static Test suite() {
42          return new TestSuite(ThreadPoolExecutorTest.class);
43      }
44  
45      static class ExtendedTPE extends ThreadPoolExecutor {
46 <        volatile boolean beforeCalled = false;
47 <        volatile boolean afterCalled = false;
48 <        volatile boolean terminatedCalled = false;
46 >        final CountDownLatch beforeCalled = new CountDownLatch(1);
47 >        final CountDownLatch afterCalled = new CountDownLatch(1);
48 >        final CountDownLatch terminatedCalled = new CountDownLatch(1);
49 >
50          public ExtendedTPE() {
51              super(1, 1, LONG_DELAY_MS, MILLISECONDS, new SynchronousQueue<Runnable>());
52          }
53          protected void beforeExecute(Thread t, Runnable r) {
54 <            beforeCalled = true;
54 >            beforeCalled.countDown();
55          }
56          protected void afterExecute(Runnable r, Throwable t) {
57 <            afterCalled = true;
57 >            afterCalled.countDown();
58          }
59          protected void terminated() {
60 <            terminatedCalled = true;
60 >            terminatedCalled.countDown();
61 >        }
62 >
63 >        public boolean beforeCalled() {
64 >            return beforeCalled.getCount() == 0;
65 >        }
66 >        public boolean afterCalled() {
67 >            return afterCalled.getCount() == 0;
68 >        }
69 >        public boolean terminatedCalled() {
70 >            return terminatedCalled.getCount() == 0;
71          }
72      }
73  
# Line 46 | Line 79 | public class ThreadPoolExecutorTest exte
79          }
80      }
81  
49 –
82      /**
83       * execute successfully executes a runnable
84       */
# Line 100 | Line 132 | public class ThreadPoolExecutorTest exte
132       */
133      public void testPrestartCoreThread() {
134          final ThreadPoolExecutor p =
135 <            new ThreadPoolExecutor(2, 2,
135 >            new ThreadPoolExecutor(2, 6,
136                                     LONG_DELAY_MS, MILLISECONDS,
137                                     new ArrayBlockingQueue<Runnable>(10));
138 <        assertEquals(0, p.getPoolSize());
139 <        assertTrue(p.prestartCoreThread());
140 <        assertEquals(1, p.getPoolSize());
141 <        assertTrue(p.prestartCoreThread());
142 <        assertEquals(2, p.getPoolSize());
143 <        assertFalse(p.prestartCoreThread());
144 <        assertEquals(2, p.getPoolSize());
145 <        joinPool(p);
138 >        try (PoolCleaner cleaner = cleaner(p)) {
139 >            assertEquals(0, p.getPoolSize());
140 >            assertTrue(p.prestartCoreThread());
141 >            assertEquals(1, p.getPoolSize());
142 >            assertTrue(p.prestartCoreThread());
143 >            assertEquals(2, p.getPoolSize());
144 >            assertFalse(p.prestartCoreThread());
145 >            assertEquals(2, p.getPoolSize());
146 >            p.setCorePoolSize(4);
147 >            assertTrue(p.prestartCoreThread());
148 >            assertEquals(3, p.getPoolSize());
149 >            assertTrue(p.prestartCoreThread());
150 >            assertEquals(4, p.getPoolSize());
151 >            assertFalse(p.prestartCoreThread());
152 >            assertEquals(4, p.getPoolSize());
153 >        }
154      }
155  
156      /**
# Line 118 | Line 158 | public class ThreadPoolExecutorTest exte
158       */
159      public void testPrestartAllCoreThreads() {
160          final ThreadPoolExecutor p =
161 <            new ThreadPoolExecutor(2, 2,
161 >            new ThreadPoolExecutor(2, 6,
162                                     LONG_DELAY_MS, MILLISECONDS,
163                                     new ArrayBlockingQueue<Runnable>(10));
164 <        assertEquals(0, p.getPoolSize());
165 <        p.prestartAllCoreThreads();
166 <        assertEquals(2, p.getPoolSize());
167 <        p.prestartAllCoreThreads();
168 <        assertEquals(2, p.getPoolSize());
169 <        joinPool(p);
164 >        try (PoolCleaner cleaner = cleaner(p)) {
165 >            assertEquals(0, p.getPoolSize());
166 >            p.prestartAllCoreThreads();
167 >            assertEquals(2, p.getPoolSize());
168 >            p.prestartAllCoreThreads();
169 >            assertEquals(2, p.getPoolSize());
170 >            p.setCorePoolSize(4);
171 >            p.prestartAllCoreThreads();
172 >            assertEquals(4, p.getPoolSize());
173 >            p.prestartAllCoreThreads();
174 >            assertEquals(4, p.getPoolSize());
175 >        }
176      }
177  
178      /**
# Line 138 | Line 184 | public class ThreadPoolExecutorTest exte
184              new ThreadPoolExecutor(2, 2,
185                                     LONG_DELAY_MS, MILLISECONDS,
186                                     new ArrayBlockingQueue<Runnable>(10));
187 <        final CountDownLatch threadStarted = new CountDownLatch(1);
188 <        final CountDownLatch threadProceed = new CountDownLatch(1);
189 <        final CountDownLatch threadDone = new CountDownLatch(1);
190 <        try {
187 >        try (PoolCleaner cleaner = cleaner(p)) {
188 >            final CountDownLatch threadStarted = new CountDownLatch(1);
189 >            final CountDownLatch threadProceed = new CountDownLatch(1);
190 >            final CountDownLatch threadDone = new CountDownLatch(1);
191              assertEquals(0, p.getCompletedTaskCount());
192              p.execute(new CheckedRunnable() {
193                  public void realRun() throws InterruptedException {
# Line 150 | Line 196 | public class ThreadPoolExecutorTest exte
196                      threadProceed.await();
197                      threadDone.countDown();
198                  }});
199 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
199 >            await(threadStarted);
200              assertEquals(0, p.getCompletedTaskCount());
201              threadProceed.countDown();
202              threadDone.await();
203 <            Thread.sleep(SHORT_DELAY_MS);
204 <            assertEquals(1, p.getCompletedTaskCount());
205 <        } finally {
206 <            joinPool(p);
203 >            long startTime = System.nanoTime();
204 >            while (p.getCompletedTaskCount() != 1) {
205 >                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
206 >                    fail("timed out");
207 >                Thread.yield();
208 >            }
209          }
210      }
211  
# Line 181 | Line 229 | public class ThreadPoolExecutorTest exte
229              new ThreadPoolExecutor(2, 2,
230                                     1000, MILLISECONDS,
231                                     new ArrayBlockingQueue<Runnable>(10));
232 <        assertEquals(1, p.getKeepAliveTime(TimeUnit.SECONDS));
232 >        assertEquals(1, p.getKeepAliveTime(SECONDS));
233          joinPool(p);
234      }
235  
188 –
236      /**
237       * getThreadFactory returns factory in constructor if not set
238       */
# Line 215 | Line 262 | public class ThreadPoolExecutorTest exte
262          joinPool(p);
263      }
264  
218 –
265      /**
266       * setThreadFactory(null) throws NPE
267       */
# Line 262 | Line 308 | public class ThreadPoolExecutorTest exte
308          joinPool(p);
309      }
310  
265 –
311      /**
312       * setRejectedExecutionHandler(null) throws NPE
313       */
# Line 280 | Line 325 | public class ThreadPoolExecutorTest exte
325          }
326      }
327  
283 –
328      /**
329       * getLargestPoolSize increases, but doesn't overestimate, when
330       * multiple threads active
# Line 378 | Line 422 | public class ThreadPoolExecutorTest exte
422      }
423  
424      /**
425 <     * isShutDown is false before shutdown, true after
425 >     * isShutdown is false before shutdown, true after
426       */
427      public void testIsShutdown() {
428          final ThreadPoolExecutor p =
# Line 391 | Line 435 | public class ThreadPoolExecutorTest exte
435          joinPool(p);
436      }
437  
438 +    /**
439 +     * awaitTermination on a non-shutdown pool times out
440 +     */
441 +    public void testAwaitTermination_timesOut() throws InterruptedException {
442 +        final ThreadPoolExecutor p =
443 +            new ThreadPoolExecutor(1, 1,
444 +                                   LONG_DELAY_MS, MILLISECONDS,
445 +                                   new ArrayBlockingQueue<Runnable>(10));
446 +        assertFalse(p.isTerminated());
447 +        assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
448 +        assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
449 +        assertFalse(p.awaitTermination(-1L, NANOSECONDS));
450 +        assertFalse(p.awaitTermination(-1L, MILLISECONDS));
451 +        assertFalse(p.awaitTermination(0L, NANOSECONDS));
452 +        assertFalse(p.awaitTermination(0L, MILLISECONDS));
453 +        long timeoutNanos = 999999L;
454 +        long startTime = System.nanoTime();
455 +        assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
456 +        assertTrue(System.nanoTime() - startTime >= timeoutNanos);
457 +        assertFalse(p.isTerminated());
458 +        startTime = System.nanoTime();
459 +        long timeoutMillis = timeoutMillis();
460 +        assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
461 +        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
462 +        assertFalse(p.isTerminated());
463 +        p.shutdown();
464 +        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
465 +        assertTrue(p.isTerminated());
466 +    }
467  
468      /**
469       * isTerminated is false before termination, true after
# Line 406 | Line 479 | public class ThreadPoolExecutorTest exte
479          try {
480              p.execute(new CheckedRunnable() {
481                  public void realRun() throws InterruptedException {
409 –                    threadStarted.countDown();
482                      assertFalse(p.isTerminated());
483 +                    threadStarted.countDown();
484                      done.await();
485                  }});
486              assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
487 +            assertFalse(p.isTerminating());
488              done.countDown();
489          } finally {
490              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 433 | Line 507 | public class ThreadPoolExecutorTest exte
507              assertFalse(p.isTerminating());
508              p.execute(new CheckedRunnable() {
509                  public void realRun() throws InterruptedException {
436 –                    threadStarted.countDown();
510                      assertFalse(p.isTerminating());
511 +                    threadStarted.countDown();
512                      done.await();
513                  }});
514              assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
# Line 563 | Line 637 | public class ThreadPoolExecutorTest exte
637      }
638  
639      /**
640 <     * shutDownNow returns a list containing tasks that were not run
640 >     * shutdownNow returns a list containing tasks that were not run,
641 >     * and those tasks are drained from the queue
642       */
643 <    public void testShutDownNow() {
643 >    public void testShutdownNow() throws InterruptedException {
644 >        final int poolSize = 2;
645 >        final int count = 5;
646 >        final AtomicInteger ran = new AtomicInteger(0);
647          final ThreadPoolExecutor p =
648 <            new ThreadPoolExecutor(1, 1,
648 >            new ThreadPoolExecutor(poolSize, poolSize,
649                                     LONG_DELAY_MS, MILLISECONDS,
650                                     new ArrayBlockingQueue<Runnable>(10));
651 <        List l;
652 <        try {
653 <            for (int i = 0; i < 5; i++)
576 <                p.execute(new MediumPossiblyInterruptedRunnable());
577 <        }
578 <        finally {
651 >        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
652 >        Runnable waiter = new CheckedRunnable() { public void realRun() {
653 >            threadsStarted.countDown();
654              try {
655 <                l = p.shutdownNow();
656 <            } catch (SecurityException ok) { return; }
655 >                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
656 >            } catch (InterruptedException success) {}
657 >            ran.getAndIncrement();
658 >        }};
659 >        for (int i = 0; i < count; i++)
660 >            p.execute(waiter);
661 >        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
662 >        assertEquals(poolSize, p.getActiveCount());
663 >        assertEquals(0, p.getCompletedTaskCount());
664 >        final List<Runnable> queuedTasks;
665 >        try {
666 >            queuedTasks = p.shutdownNow();
667 >        } catch (SecurityException ok) {
668 >            return; // Allowed in case test doesn't have privs
669          }
670          assertTrue(p.isShutdown());
671 <        assertTrue(l.size() <= 4);
671 >        assertTrue(p.getQueue().isEmpty());
672 >        assertEquals(count - poolSize, queuedTasks.size());
673 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
674 >        assertTrue(p.isTerminated());
675 >        assertEquals(poolSize, ran.get());
676 >        assertEquals(poolSize, p.getCompletedTaskCount());
677      }
678  
679      // Exception Tests
680  
589 –
681      /**
682       * Constructor throws if corePoolSize argument is less than zero
683       */
684      public void testConstructor1() {
685          try {
686 <            new ThreadPoolExecutor(-1, 1,
596 <                                   LONG_DELAY_MS, MILLISECONDS,
686 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
687                                     new ArrayBlockingQueue<Runnable>(10));
688              shouldThrow();
689          } catch (IllegalArgumentException success) {}
# Line 604 | Line 694 | public class ThreadPoolExecutorTest exte
694       */
695      public void testConstructor2() {
696          try {
697 <            new ThreadPoolExecutor(1, -1,
608 <                                   LONG_DELAY_MS, MILLISECONDS,
697 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
698                                     new ArrayBlockingQueue<Runnable>(10));
699              shouldThrow();
700          } catch (IllegalArgumentException success) {}
# Line 616 | Line 705 | public class ThreadPoolExecutorTest exte
705       */
706      public void testConstructor3() {
707          try {
708 <            new ThreadPoolExecutor(1, 0,
620 <                                   LONG_DELAY_MS, MILLISECONDS,
708 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
709                                     new ArrayBlockingQueue<Runnable>(10));
710              shouldThrow();
711          } catch (IllegalArgumentException success) {}
# Line 628 | Line 716 | public class ThreadPoolExecutorTest exte
716       */
717      public void testConstructor4() {
718          try {
719 <            new ThreadPoolExecutor(1, 2,
632 <                                   -1L, MILLISECONDS,
719 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
720                                     new ArrayBlockingQueue<Runnable>(10));
721              shouldThrow();
722          } catch (IllegalArgumentException success) {}
# Line 640 | Line 727 | public class ThreadPoolExecutorTest exte
727       */
728      public void testConstructor5() {
729          try {
730 <            new ThreadPoolExecutor(2, 1,
644 <                                   LONG_DELAY_MS, MILLISECONDS,
730 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
731                                     new ArrayBlockingQueue<Runnable>(10));
732              shouldThrow();
733          } catch (IllegalArgumentException success) {}
# Line 652 | Line 738 | public class ThreadPoolExecutorTest exte
738       */
739      public void testConstructorNullPointerException() {
740          try {
741 <            new ThreadPoolExecutor(1, 2,
656 <                                   LONG_DELAY_MS, MILLISECONDS,
741 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
742                                     (BlockingQueue) null);
743              shouldThrow();
744          } catch (NullPointerException success) {}
745      }
746  
662 –
663 –
747      /**
748       * Constructor throws if corePoolSize argument is less than zero
749       */
750      public void testConstructor6() {
751          try {
752 <            new ThreadPoolExecutor(-1, 1,
670 <                                   LONG_DELAY_MS, MILLISECONDS,
752 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
753                                     new ArrayBlockingQueue<Runnable>(10),
754                                     new SimpleThreadFactory());
755              shouldThrow();
# Line 679 | Line 761 | public class ThreadPoolExecutorTest exte
761       */
762      public void testConstructor7() {
763          try {
764 <            new ThreadPoolExecutor(1, -1,
683 <                                   LONG_DELAY_MS, MILLISECONDS,
764 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
765                                     new ArrayBlockingQueue<Runnable>(10),
766                                     new SimpleThreadFactory());
767              shouldThrow();
# Line 692 | Line 773 | public class ThreadPoolExecutorTest exte
773       */
774      public void testConstructor8() {
775          try {
776 <            new ThreadPoolExecutor(1, 0,
696 <                                   LONG_DELAY_MS, MILLISECONDS,
776 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
777                                     new ArrayBlockingQueue<Runnable>(10),
778                                     new SimpleThreadFactory());
779              shouldThrow();
# Line 705 | Line 785 | public class ThreadPoolExecutorTest exte
785       */
786      public void testConstructor9() {
787          try {
788 <            new ThreadPoolExecutor(1, 2,
709 <                                   -1L, MILLISECONDS,
788 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
789                                     new ArrayBlockingQueue<Runnable>(10),
790                                     new SimpleThreadFactory());
791              shouldThrow();
# Line 718 | Line 797 | public class ThreadPoolExecutorTest exte
797       */
798      public void testConstructor10() {
799          try {
800 <            new ThreadPoolExecutor(2, 1,
722 <                                   LONG_DELAY_MS, MILLISECONDS,
800 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
801                                     new ArrayBlockingQueue<Runnable>(10),
802                                     new SimpleThreadFactory());
803              shouldThrow();
# Line 731 | Line 809 | public class ThreadPoolExecutorTest exte
809       */
810      public void testConstructorNullPointerException2() {
811          try {
812 <            new ThreadPoolExecutor(1, 2,
735 <                                   LONG_DELAY_MS, MILLISECONDS,
812 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
813                                     (BlockingQueue) null,
814                                     new SimpleThreadFactory());
815              shouldThrow();
# Line 744 | Line 821 | public class ThreadPoolExecutorTest exte
821       */
822      public void testConstructorNullPointerException3() {
823          try {
824 <            new ThreadPoolExecutor(1, 2,
748 <                                   LONG_DELAY_MS, MILLISECONDS,
824 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
825                                     new ArrayBlockingQueue<Runnable>(10),
826                                     (ThreadFactory) null);
827              shouldThrow();
828          } catch (NullPointerException success) {}
829      }
830  
755 –
831      /**
832       * Constructor throws if corePoolSize argument is less than zero
833       */
834      public void testConstructor11() {
835          try {
836 <            new ThreadPoolExecutor(-1, 1,
762 <                                   LONG_DELAY_MS, MILLISECONDS,
836 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
837                                     new ArrayBlockingQueue<Runnable>(10),
838                                     new NoOpREHandler());
839              shouldThrow();
# Line 771 | Line 845 | public class ThreadPoolExecutorTest exte
845       */
846      public void testConstructor12() {
847          try {
848 <            new ThreadPoolExecutor(1, -1,
775 <                                   LONG_DELAY_MS, MILLISECONDS,
848 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
849                                     new ArrayBlockingQueue<Runnable>(10),
850                                     new NoOpREHandler());
851              shouldThrow();
# Line 784 | Line 857 | public class ThreadPoolExecutorTest exte
857       */
858      public void testConstructor13() {
859          try {
860 <            new ThreadPoolExecutor(1, 0,
788 <                                   LONG_DELAY_MS, MILLISECONDS,
860 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
861                                     new ArrayBlockingQueue<Runnable>(10),
862                                     new NoOpREHandler());
863              shouldThrow();
# Line 797 | Line 869 | public class ThreadPoolExecutorTest exte
869       */
870      public void testConstructor14() {
871          try {
872 <            new ThreadPoolExecutor(1, 2,
801 <                                   -1L, MILLISECONDS,
872 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
873                                     new ArrayBlockingQueue<Runnable>(10),
874                                     new NoOpREHandler());
875              shouldThrow();
# Line 810 | Line 881 | public class ThreadPoolExecutorTest exte
881       */
882      public void testConstructor15() {
883          try {
884 <            new ThreadPoolExecutor(2, 1,
814 <                                   LONG_DELAY_MS, MILLISECONDS,
884 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
885                                     new ArrayBlockingQueue<Runnable>(10),
886                                     new NoOpREHandler());
887              shouldThrow();
# Line 823 | Line 893 | public class ThreadPoolExecutorTest exte
893       */
894      public void testConstructorNullPointerException4() {
895          try {
896 <            new ThreadPoolExecutor(1, 2,
827 <                                   LONG_DELAY_MS, MILLISECONDS,
896 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
897                                     (BlockingQueue) null,
898                                     new NoOpREHandler());
899              shouldThrow();
# Line 836 | Line 905 | public class ThreadPoolExecutorTest exte
905       */
906      public void testConstructorNullPointerException5() {
907          try {
908 <            new ThreadPoolExecutor(1, 2,
840 <                                   LONG_DELAY_MS, MILLISECONDS,
908 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
909                                     new ArrayBlockingQueue<Runnable>(10),
910                                     (RejectedExecutionHandler) null);
911              shouldThrow();
912          } catch (NullPointerException success) {}
913      }
914  
847 –
915      /**
916       * Constructor throws if corePoolSize argument is less than zero
917       */
918      public void testConstructor16() {
919          try {
920 <            new ThreadPoolExecutor(-1, 1,
854 <                                   LONG_DELAY_MS, MILLISECONDS,
920 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
921                                     new ArrayBlockingQueue<Runnable>(10),
922                                     new SimpleThreadFactory(),
923                                     new NoOpREHandler());
# Line 864 | Line 930 | public class ThreadPoolExecutorTest exte
930       */
931      public void testConstructor17() {
932          try {
933 <            new ThreadPoolExecutor(1, -1,
868 <                                   LONG_DELAY_MS, MILLISECONDS,
933 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
934                                     new ArrayBlockingQueue<Runnable>(10),
935                                     new SimpleThreadFactory(),
936                                     new NoOpREHandler());
# Line 878 | Line 943 | public class ThreadPoolExecutorTest exte
943       */
944      public void testConstructor18() {
945          try {
946 <            new ThreadPoolExecutor(1, 0,
882 <                                   LONG_DELAY_MS, MILLISECONDS,
946 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
947                                     new ArrayBlockingQueue<Runnable>(10),
948                                     new SimpleThreadFactory(),
949                                     new NoOpREHandler());
# Line 892 | Line 956 | public class ThreadPoolExecutorTest exte
956       */
957      public void testConstructor19() {
958          try {
959 <            new ThreadPoolExecutor(1, 2,
896 <                                   -1L, MILLISECONDS,
959 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
960                                     new ArrayBlockingQueue<Runnable>(10),
961                                     new SimpleThreadFactory(),
962                                     new NoOpREHandler());
# Line 906 | Line 969 | public class ThreadPoolExecutorTest exte
969       */
970      public void testConstructor20() {
971          try {
972 <            new ThreadPoolExecutor(2, 1,
910 <                                   LONG_DELAY_MS, MILLISECONDS,
972 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
973                                     new ArrayBlockingQueue<Runnable>(10),
974                                     new SimpleThreadFactory(),
975                                     new NoOpREHandler());
# Line 920 | Line 982 | public class ThreadPoolExecutorTest exte
982       */
983      public void testConstructorNullPointerException6() {
984          try {
985 <            new ThreadPoolExecutor(1, 2,
924 <                                   LONG_DELAY_MS, MILLISECONDS,
985 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
986                                     (BlockingQueue) null,
987                                     new SimpleThreadFactory(),
988                                     new NoOpREHandler());
# Line 934 | Line 995 | public class ThreadPoolExecutorTest exte
995       */
996      public void testConstructorNullPointerException7() {
997          try {
998 <            new ThreadPoolExecutor(1, 2,
938 <                                   LONG_DELAY_MS, MILLISECONDS,
998 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
999                                     new ArrayBlockingQueue<Runnable>(10),
1000                                     new SimpleThreadFactory(),
1001                                     (RejectedExecutionHandler) null);
# Line 948 | Line 1008 | public class ThreadPoolExecutorTest exte
1008       */
1009      public void testConstructorNullPointerException8() {
1010          try {
1011 <            new ThreadPoolExecutor(1, 2,
952 <                                   LONG_DELAY_MS, MILLISECONDS,
1011 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1012                                     new ArrayBlockingQueue<Runnable>(10),
1013                                     (ThreadFactory) null,
1014                                     new NoOpREHandler());
# Line 963 | Line 1022 | public class ThreadPoolExecutorTest exte
1022      public void testInterruptedSubmit() throws InterruptedException {
1023          final ThreadPoolExecutor p =
1024              new ThreadPoolExecutor(1, 1,
1025 <                                   60, TimeUnit.SECONDS,
1025 >                                   60, SECONDS,
1026                                     new ArrayBlockingQueue<Runnable>(10));
1027  
1028          final CountDownLatch threadStarted = new CountDownLatch(1);
# Line 1211 | Line 1270 | public class ThreadPoolExecutorTest exte
1270          }
1271      }
1272  
1214 –
1273      /**
1274       * execute using DiscardOldestPolicy drops task on shutdown
1275       */
# Line 1233 | Line 1291 | public class ThreadPoolExecutorTest exte
1291          }
1292      }
1293  
1236 –
1294      /**
1295       * execute(null) throws NPE
1296       */
1297      public void testExecuteNull() {
1298          ThreadPoolExecutor p =
1299 <            new ThreadPoolExecutor(1, 2,
1243 <                                   LONG_DELAY_MS, MILLISECONDS,
1299 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1300                                     new ArrayBlockingQueue<Runnable>(10));
1301          try {
1302              p.execute(null);
# Line 1306 | Line 1362 | public class ThreadPoolExecutorTest exte
1362          joinPool(p);
1363      }
1364  
1365 +    /**
1366 +     * Configuration changes that allow core pool size greater than
1367 +     * max pool size result in IllegalArgumentException.
1368 +     */
1369 +    public void testPoolSizeInvariants() {
1370 +        ThreadPoolExecutor p =
1371 +            new ThreadPoolExecutor(1, 1,
1372 +                                   LONG_DELAY_MS, MILLISECONDS,
1373 +                                   new ArrayBlockingQueue<Runnable>(10));
1374 +        for (int s = 1; s < 5; s++) {
1375 +            p.setMaximumPoolSize(s);
1376 +            p.setCorePoolSize(s);
1377 +            try {
1378 +                p.setMaximumPoolSize(s - 1);
1379 +                shouldThrow();
1380 +            } catch (IllegalArgumentException success) {}
1381 +            assertEquals(s, p.getCorePoolSize());
1382 +            assertEquals(s, p.getMaximumPoolSize());
1383 +            try {
1384 +                p.setCorePoolSize(s + 1);
1385 +                shouldThrow();
1386 +            } catch (IllegalArgumentException success) {}
1387 +            assertEquals(s, p.getCorePoolSize());
1388 +            assertEquals(s, p.getMaximumPoolSize());
1389 +        }
1390 +        joinPool(p);
1391 +    }
1392  
1393      /**
1394       * setKeepAliveTime throws IllegalArgumentException
# Line 1332 | Line 1415 | public class ThreadPoolExecutorTest exte
1415      public void testTerminated() {
1416          ExtendedTPE p = new ExtendedTPE();
1417          try { p.shutdown(); } catch (SecurityException ok) { return; }
1418 <        assertTrue(p.terminatedCalled);
1418 >        assertTrue(p.terminatedCalled());
1419          joinPool(p);
1420      }
1421  
# Line 1342 | Line 1425 | public class ThreadPoolExecutorTest exte
1425      public void testBeforeAfter() throws InterruptedException {
1426          ExtendedTPE p = new ExtendedTPE();
1427          try {
1428 <            TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1429 <            p.execute(r);
1430 <            Thread.sleep(SHORT_DELAY_MS);
1431 <            assertTrue(r.done);
1432 <            assertTrue(p.beforeCalled);
1433 <            assertTrue(p.afterCalled);
1428 >            final CountDownLatch done = new CountDownLatch(1);
1429 >            p.execute(new CheckedRunnable() {
1430 >                public void realRun() {
1431 >                    done.countDown();
1432 >                }});
1433 >            await(p.afterCalled);
1434 >            assertEquals(0, done.getCount());
1435 >            assertTrue(p.afterCalled());
1436 >            assertTrue(p.beforeCalled());
1437              try { p.shutdown(); } catch (SecurityException ok) { return; }
1438          } finally {
1439              joinPool(p);
# Line 1405 | Line 1491 | public class ThreadPoolExecutorTest exte
1491          }
1492      }
1493  
1408 –
1494      /**
1495       * invokeAny(null) throws NPE
1496       */
# Line 1599 | Line 1684 | public class ThreadPoolExecutorTest exte
1684          }
1685      }
1686  
1602 –
1603 –
1687      /**
1688       * timed invokeAny(null) throws NPE
1689       */
# Line 1823 | Line 1906 | public class ThreadPoolExecutorTest exte
1906              l.add(new StringTask());
1907              l.add(new StringTask());
1908              List<Future<String>> futures =
1909 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1909 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1910              assertEquals(2, futures.size());
1911              for (Future<String> future : futures)
1912                  assertSame(TEST_STRING, future.get());
# Line 1841 | Line 1924 | public class ThreadPoolExecutorTest exte
1924                                     LONG_DELAY_MS, MILLISECONDS,
1925                                     new ArrayBlockingQueue<Runnable>(10));
1926          try {
1927 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1928 <            l.add(new StringTask());
1929 <            l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1930 <            l.add(new StringTask());
1931 <            List<Future<String>> futures =
1932 <                e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1933 <            assertEquals(3, futures.size());
1934 <            Iterator<Future<String>> it = futures.iterator();
1935 <            Future<String> f1 = it.next();
1936 <            Future<String> f2 = it.next();
1937 <            Future<String> f3 = it.next();
1938 <            assertTrue(f1.isDone());
1939 <            assertTrue(f2.isDone());
1940 <            assertTrue(f3.isDone());
1941 <            assertFalse(f1.isCancelled());
1942 <            assertTrue(f2.isCancelled());
1927 >            for (long timeout = timeoutMillis();;) {
1928 >                List<Callable<String>> tasks = new ArrayList<>();
1929 >                tasks.add(new StringTask("0"));
1930 >                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1931 >                tasks.add(new StringTask("2"));
1932 >                long startTime = System.nanoTime();
1933 >                List<Future<String>> futures =
1934 >                    e.invokeAll(tasks, timeout, MILLISECONDS);
1935 >                assertEquals(tasks.size(), futures.size());
1936 >                assertTrue(millisElapsedSince(startTime) >= timeout);
1937 >                for (Future future : futures)
1938 >                    assertTrue(future.isDone());
1939 >                assertTrue(futures.get(1).isCancelled());
1940 >                try {
1941 >                    assertEquals("0", futures.get(0).get());
1942 >                    assertEquals("2", futures.get(2).get());
1943 >                    break;
1944 >                } catch (CancellationException retryWithLongerTimeout) {
1945 >                    timeout *= 2;
1946 >                    if (timeout >= LONG_DELAY_MS / 2)
1947 >                        fail("expected exactly one task to be cancelled");
1948 >                }
1949 >            }
1950          } finally {
1951              joinPool(e);
1952          }
# Line 1902 | Line 1992 | public class ThreadPoolExecutorTest exte
1992       * allowCoreThreadTimeOut(true) causes idle threads to time out
1993       */
1994      public void testAllowCoreThreadTimeOut_true() throws Exception {
1995 +        long keepAliveTime = timeoutMillis();
1996          final ThreadPoolExecutor p =
1997              new ThreadPoolExecutor(2, 10,
1998 <                                   SHORT_DELAY_MS, MILLISECONDS,
1998 >                                   keepAliveTime, MILLISECONDS,
1999                                     new ArrayBlockingQueue<Runnable>(10));
2000          final CountDownLatch threadStarted = new CountDownLatch(1);
2001          try {
2002              p.allowCoreThreadTimeOut(true);
2003              p.execute(new CheckedRunnable() {
2004 <                public void realRun() throws InterruptedException {
2004 >                public void realRun() {
2005                      threadStarted.countDown();
2006                      assertEquals(1, p.getPoolSize());
2007                  }});
2008 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
2009 <            for (int i = 0; i < (MEDIUM_DELAY_MS/10); i++) {
2010 <                if (p.getPoolSize() == 0)
2011 <                    break;
2012 <                Thread.sleep(10);
2013 <            }
2008 >            await(threadStarted);
2009 >            delay(keepAliveTime);
2010 >            long startTime = System.nanoTime();
2011 >            while (p.getPoolSize() > 0
2012 >                   && millisElapsedSince(startTime) < LONG_DELAY_MS)
2013 >                Thread.yield();
2014 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
2015              assertEquals(0, p.getPoolSize());
2016          } finally {
2017              joinPool(p);
# Line 1930 | Line 2022 | public class ThreadPoolExecutorTest exte
2022       * allowCoreThreadTimeOut(false) causes idle threads not to time out
2023       */
2024      public void testAllowCoreThreadTimeOut_false() throws Exception {
2025 +        long keepAliveTime = timeoutMillis();
2026          final ThreadPoolExecutor p =
2027              new ThreadPoolExecutor(2, 10,
2028 <                                   SHORT_DELAY_MS, MILLISECONDS,
2028 >                                   keepAliveTime, MILLISECONDS,
2029                                     new ArrayBlockingQueue<Runnable>(10));
2030          final CountDownLatch threadStarted = new CountDownLatch(1);
2031          try {
# Line 1942 | Line 2035 | public class ThreadPoolExecutorTest exte
2035                      threadStarted.countDown();
2036                      assertTrue(p.getPoolSize() >= 1);
2037                  }});
2038 <            Thread.sleep(SMALL_DELAY_MS);
2038 >            delay(2 * keepAliveTime);
2039              assertTrue(p.getPoolSize() >= 1);
2040          } finally {
2041              joinPool(p);
# Line 1961 | Line 2054 | public class ThreadPoolExecutorTest exte
2054                  done.countDown();
2055              }};
2056          final ThreadPoolExecutor p =
2057 <            new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
2057 >            new ThreadPoolExecutor(1, 30,
2058 >                                   60, SECONDS,
2059                                     new ArrayBlockingQueue(30));
2060          try {
2061              for (int i = 0; i < nTasks; ++i) {
# Line 1976 | Line 2070 | public class ThreadPoolExecutorTest exte
2070              // enough time to run all tasks
2071              assertTrue(done.await(nTasks * SHORT_DELAY_MS, MILLISECONDS));
2072          } finally {
2073 <            p.shutdown();
2073 >            joinPool(p);
2074 >        }
2075 >    }
2076 >
2077 >    /**
2078 >     * get(cancelled task) throws CancellationException
2079 >     */
2080 >    public void testGet_cancelled() throws Exception {
2081 >        final ExecutorService e =
2082 >            new ThreadPoolExecutor(1, 1,
2083 >                                   LONG_DELAY_MS, MILLISECONDS,
2084 >                                   new LinkedBlockingQueue<Runnable>());
2085 >        try {
2086 >            final CountDownLatch blockerStarted = new CountDownLatch(1);
2087 >            final CountDownLatch done = new CountDownLatch(1);
2088 >            final List<Future<?>> futures = new ArrayList<>();
2089 >            for (int i = 0; i < 2; i++) {
2090 >                Runnable r = new CheckedRunnable() { public void realRun()
2091 >                                                         throws Throwable {
2092 >                    blockerStarted.countDown();
2093 >                    assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
2094 >                }};
2095 >                futures.add(e.submit(r));
2096 >            }
2097 >            assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2098 >            for (Future<?> future : futures) future.cancel(false);
2099 >            for (Future<?> future : futures) {
2100 >                try {
2101 >                    future.get();
2102 >                    shouldThrow();
2103 >                } catch (CancellationException success) {}
2104 >                try {
2105 >                    future.get(LONG_DELAY_MS, MILLISECONDS);
2106 >                    shouldThrow();
2107 >                } catch (CancellationException success) {}
2108 >                assertTrue(future.isCancelled());
2109 >                assertTrue(future.isDone());
2110 >            }
2111 >            done.countDown();
2112 >        } finally {
2113 >            joinPool(e);
2114          }
2115      }
2116  

Diff Legend

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