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

Comparing jsr166/src/test/tck/ForkJoinPoolTest.java (file contents):
Revision 1.67 by jsr166, Thu Oct 8 03:03:36 2015 UTC vs.
Revision 1.72 by jsr166, Wed Jan 4 06:09:58 2017 UTC

# Line 24 | Line 24 | import java.util.concurrent.Future;
24   import java.util.concurrent.RecursiveTask;
25   import java.util.concurrent.RejectedExecutionException;
26   import java.util.concurrent.atomic.AtomicBoolean;
27 + import java.util.concurrent.atomic.AtomicInteger;
28   import java.util.concurrent.locks.ReentrantLock;
29  
30   import junit.framework.AssertionFailedError;
# Line 57 | Line 58 | public class ForkJoinPoolTest extends JS
58  
59      // Some classes to test extension and factory methods
60  
60 –    static class MyHandler implements Thread.UncaughtExceptionHandler {
61 –        volatile int catches = 0;
62 –        public void uncaughtException(Thread t, Throwable e) {
63 –            ++catches;
64 –        }
65 –    }
66 –
61      static class MyError extends Error {}
62  
63      // to test handlers
# Line 74 | Line 68 | public class ForkJoinPoolTest extends JS
68  
69      static class FailingThreadFactory
70              implements ForkJoinPool.ForkJoinWorkerThreadFactory {
71 <        volatile int calls = 0;
71 >        final AtomicInteger calls = new AtomicInteger(0);
72          public ForkJoinWorkerThread newThread(ForkJoinPool p) {
73 <            if (++calls > 1) return null;
73 >            if (calls.incrementAndGet() > 1) return null;
74              return new FailingFJWSubclass(p);
75          }
76      }
# Line 213 | Line 207 | public class ForkJoinPoolTest extends JS
207       * getPoolSize returns number of started workers.
208       */
209      public void testGetPoolSize() {
210 <        ForkJoinPool p = new ForkJoinPool(1);
210 >        final CountDownLatch taskStarted = new CountDownLatch(1);
211 >        final CountDownLatch done = new CountDownLatch(1);
212 >        final ForkJoinPool p = new ForkJoinPool(1);
213          try (PoolCleaner cleaner = cleaner(p)) {
214              assertEquals(0, p.getActiveThreadCount());
215 <            Future<String> future = p.submit(new StringTask());
215 >            final Runnable task = new CheckedRunnable() {
216 >                public void realRun() throws InterruptedException {
217 >                    taskStarted.countDown();
218 >                    assertEquals(1, p.getPoolSize());
219 >                    assertEquals(1, p.getActiveThreadCount());
220 >                    done.await();
221 >                }};
222 >            Future<?> future = p.submit(task);
223 >            await(taskStarted);
224              assertEquals(1, p.getPoolSize());
225 +            assertEquals(1, p.getActiveThreadCount());
226 +            done.countDown();
227          }
228 +        assertEquals(0, p.getPoolSize());
229 +        assertEquals(0, p.getActiveThreadCount());
230      }
231  
232      /**
# Line 305 | Line 313 | public class ForkJoinPoolTest extends JS
313  
314              assertTrue(p.isQuiescent());
315              assertFalse(p.getAsyncMode());
308 –            assertEquals(0, p.getActiveThreadCount());
316              assertEquals(0, p.getQueuedTaskCount());
317              assertEquals(0, p.getQueuedSubmissionCount());
318              assertFalse(p.hasQueuedSubmissions());
319 +            while (p.getActiveThreadCount() != 0
320 +                   && millisElapsedSince(startTime) < LONG_DELAY_MS)
321 +                Thread.yield();
322              assertFalse(p.isShutdown());
323              assertFalse(p.isTerminating());
324              assertFalse(p.isTerminated());
325              assertTrue(f.isDone());
326              assertEquals(6765, (int) f.get());
327 +            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
328          }
329      }
330  
# Line 620 | Line 631 | public class ForkJoinPoolTest extends JS
631      public void testInvokeAny3() throws Throwable {
632          ExecutorService e = new ForkJoinPool(1);
633          try (PoolCleaner cleaner = cleaner(e)) {
634 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
634 >            List<Callable<String>> l = new ArrayList<>();
635              l.add(null);
636              try {
637                  e.invokeAny(l);
# Line 636 | Line 647 | public class ForkJoinPoolTest extends JS
647          CountDownLatch latch = new CountDownLatch(1);
648          ExecutorService e = new ForkJoinPool(1);
649          try (PoolCleaner cleaner = cleaner(e)) {
650 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
650 >            List<Callable<String>> l = new ArrayList<>();
651              l.add(latchAwaitingStringTask(latch));
652              l.add(null);
653              try {
# Line 653 | Line 664 | public class ForkJoinPoolTest extends JS
664      public void testInvokeAny5() throws Throwable {
665          ExecutorService e = new ForkJoinPool(1);
666          try (PoolCleaner cleaner = cleaner(e)) {
667 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
667 >            List<Callable<String>> l = new ArrayList<>();
668              l.add(new NPETask());
669              try {
670                  e.invokeAny(l);
# Line 670 | Line 681 | public class ForkJoinPoolTest extends JS
681      public void testInvokeAny6() throws Throwable {
682          ExecutorService e = new ForkJoinPool(1);
683          try (PoolCleaner cleaner = cleaner(e)) {
684 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
684 >            List<Callable<String>> l = new ArrayList<>();
685              l.add(new StringTask());
686              l.add(new StringTask());
687              String result = e.invokeAny(l);
# Line 709 | Line 720 | public class ForkJoinPoolTest extends JS
720      public void testInvokeAll3() throws InterruptedException {
721          ExecutorService e = new ForkJoinPool(1);
722          try (PoolCleaner cleaner = cleaner(e)) {
723 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
723 >            List<Callable<String>> l = new ArrayList<>();
724              l.add(new StringTask());
725              l.add(null);
726              try {
# Line 726 | Line 737 | public class ForkJoinPoolTest extends JS
737      public void testInvokeAll4() throws Throwable {
738          ExecutorService e = new ForkJoinPool(1);
739          try (PoolCleaner cleaner = cleaner(e)) {
740 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
740 >            List<Callable<String>> l = new ArrayList<>();
741              l.add(new NPETask());
742              List<Future<String>> futures = e.invokeAll(l);
743              assertEquals(1, futures.size());
# Line 745 | Line 756 | public class ForkJoinPoolTest extends JS
756      public void testInvokeAll5() throws Throwable {
757          ExecutorService e = new ForkJoinPool(1);
758          try (PoolCleaner cleaner = cleaner(e)) {
759 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
759 >            List<Callable<String>> l = new ArrayList<>();
760              l.add(new StringTask());
761              l.add(new StringTask());
762              List<Future<String>> futures = e.invokeAll(l);
# Line 774 | Line 785 | public class ForkJoinPoolTest extends JS
785      public void testTimedInvokeAnyNullTimeUnit() throws Throwable {
786          ExecutorService e = new ForkJoinPool(1);
787          try (PoolCleaner cleaner = cleaner(e)) {
788 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
788 >            List<Callable<String>> l = new ArrayList<>();
789              l.add(new StringTask());
790              try {
791                  e.invokeAny(l, MEDIUM_DELAY_MS, null);
# Line 804 | Line 815 | public class ForkJoinPoolTest extends JS
815          CountDownLatch latch = new CountDownLatch(1);
816          ExecutorService e = new ForkJoinPool(1);
817          try (PoolCleaner cleaner = cleaner(e)) {
818 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
818 >            List<Callable<String>> l = new ArrayList<>();
819              l.add(latchAwaitingStringTask(latch));
820              l.add(null);
821              try {
# Line 822 | Line 833 | public class ForkJoinPoolTest extends JS
833          ExecutorService e = new ForkJoinPool(1);
834          try (PoolCleaner cleaner = cleaner(e)) {
835              long startTime = System.nanoTime();
836 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
836 >            List<Callable<String>> l = new ArrayList<>();
837              l.add(new NPETask());
838              try {
839                  e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
# Line 840 | Line 851 | public class ForkJoinPoolTest extends JS
851      public void testTimedInvokeAny5() throws Throwable {
852          ExecutorService e = new ForkJoinPool(1);
853          try (PoolCleaner cleaner = cleaner(e)) {
854 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
854 >            long startTime = System.nanoTime();
855 >            List<Callable<String>> l = new ArrayList<>();
856              l.add(new StringTask());
857              l.add(new StringTask());
858 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
858 >            String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
859              assertSame(TEST_STRING, result);
860 +            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
861          }
862      }
863  
# Line 867 | Line 880 | public class ForkJoinPoolTest extends JS
880      public void testTimedInvokeAllNullTimeUnit() throws Throwable {
881          ExecutorService e = new ForkJoinPool(1);
882          try (PoolCleaner cleaner = cleaner(e)) {
883 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
883 >            List<Callable<String>> l = new ArrayList<>();
884              l.add(new StringTask());
885              try {
886                  e.invokeAll(l, MEDIUM_DELAY_MS, null);
# Line 895 | Line 908 | public class ForkJoinPoolTest extends JS
908      public void testTimedInvokeAll3() throws InterruptedException {
909          ExecutorService e = new ForkJoinPool(1);
910          try (PoolCleaner cleaner = cleaner(e)) {
911 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
911 >            List<Callable<String>> l = new ArrayList<>();
912              l.add(new StringTask());
913              l.add(null);
914              try {
# Line 911 | Line 924 | public class ForkJoinPoolTest extends JS
924      public void testTimedInvokeAll4() throws Throwable {
925          ExecutorService e = new ForkJoinPool(1);
926          try (PoolCleaner cleaner = cleaner(e)) {
927 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
927 >            List<Callable<String>> l = new ArrayList<>();
928              l.add(new NPETask());
929              List<Future<String>> futures
930                  = e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
# Line 931 | Line 944 | public class ForkJoinPoolTest extends JS
944      public void testTimedInvokeAll5() throws Throwable {
945          ForkJoinPool e = new ForkJoinPool(1);
946          try (PoolCleaner cleaner = cleaner(e)) {
947 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
947 >            List<Callable<String>> l = new ArrayList<>();
948              l.add(new StringTask());
949              l.add(new StringTask());
950              List<Future<String>> futures

Diff Legend

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