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.70 by jsr166, Tue Oct 13 21:18:28 2015 UTC vs.
Revision 1.76 by jsr166, Tue Jan 23 20:44:11 2018 UTC

# Line 11 | Line 11 | import java.security.PrivilegedAction;
11   import java.security.PrivilegedExceptionAction;
12   import java.util.ArrayList;
13   import java.util.Collection;
14 + import java.util.Collections;
15   import java.util.List;
16   import java.util.concurrent.Callable;
17   import java.util.concurrent.CountDownLatch;
# Line 24 | Line 25 | import java.util.concurrent.Future;
25   import java.util.concurrent.RecursiveTask;
26   import java.util.concurrent.RejectedExecutionException;
27   import java.util.concurrent.atomic.AtomicBoolean;
28 + import java.util.concurrent.atomic.AtomicInteger;
29   import java.util.concurrent.locks.ReentrantLock;
30  
29 – import junit.framework.AssertionFailedError;
31   import junit.framework.Test;
32   import junit.framework.TestSuite;
33  
# 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 223 | Line 217 | public class ForkJoinPoolTest extends JS
217                      taskStarted.countDown();
218                      assertEquals(1, p.getPoolSize());
219                      assertEquals(1, p.getActiveThreadCount());
220 <                    done.await();
220 >                    await(done);
221                  }};
222              Future<?> future = p.submit(task);
223              await(taskStarted);
# Line 246 | Line 240 | public class ForkJoinPoolTest extends JS
240              assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
241              assertFalse(p.awaitTermination(-1L, NANOSECONDS));
242              assertFalse(p.awaitTermination(-1L, MILLISECONDS));
243 <            assertFalse(p.awaitTermination(0L, NANOSECONDS));
244 <            assertFalse(p.awaitTermination(0L, MILLISECONDS));
243 >            assertFalse(p.awaitTermination(randomExpiredTimeout(),
244 >                                           randomTimeUnit()));
245              long timeoutNanos = 999999L;
246              long startTime = System.nanoTime();
247              assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
# Line 309 | Line 303 | public class ForkJoinPoolTest extends JS
303                         p.getFactory());
304              while (! p.isQuiescent()) {
305                  if (millisElapsedSince(startTime) > LONG_DELAY_MS)
306 <                    throw new AssertionFailedError("timed out");
306 >                    throw new AssertionError("timed out");
307                  assertFalse(p.getAsyncMode());
308                  assertFalse(p.isShutdown());
309                  assertFalse(p.isTerminating());
# Line 428 | Line 422 | public class ForkJoinPoolTest extends JS
422                      done.set(true);
423                  }});
424              assertNull(future.get());
425 <            assertNull(future.get(0, MILLISECONDS));
425 >            assertNull(future.get(randomExpiredTimeout(), randomTimeUnit()));
426              assertTrue(done.get());
427              assertTrue(future.isDone());
428              assertFalse(future.isCancelled());
# Line 637 | 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 653 | 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 670 | 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 687 | 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 703 | public class ForkJoinPoolTest extends JS
703      }
704  
705      /**
706 <     * invokeAll(empty collection) returns empty collection
706 >     * invokeAll(empty collection) returns empty list
707       */
708      public void testInvokeAll2() throws InterruptedException {
709          ExecutorService e = new ForkJoinPool(1);
710 +        final Collection<Callable<String>> emptyCollection
711 +            = Collections.emptyList();
712          try (PoolCleaner cleaner = cleaner(e)) {
713 <            List<Future<String>> r
718 <                = e.invokeAll(new ArrayList<Callable<String>>());
713 >            List<Future<String>> r = e.invokeAll(emptyCollection);
714              assertTrue(r.isEmpty());
715          }
716      }
# Line 726 | Line 721 | public class ForkJoinPoolTest extends JS
721      public void testInvokeAll3() throws InterruptedException {
722          ExecutorService e = new ForkJoinPool(1);
723          try (PoolCleaner cleaner = cleaner(e)) {
724 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
724 >            List<Callable<String>> l = new ArrayList<>();
725              l.add(new StringTask());
726              l.add(null);
727              try {
# Line 743 | Line 738 | public class ForkJoinPoolTest extends JS
738      public void testInvokeAll4() throws Throwable {
739          ExecutorService e = new ForkJoinPool(1);
740          try (PoolCleaner cleaner = cleaner(e)) {
741 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
741 >            List<Callable<String>> l = new ArrayList<>();
742              l.add(new NPETask());
743              List<Future<String>> futures = e.invokeAll(l);
744              assertEquals(1, futures.size());
# Line 762 | Line 757 | public class ForkJoinPoolTest extends JS
757      public void testInvokeAll5() throws Throwable {
758          ExecutorService e = new ForkJoinPool(1);
759          try (PoolCleaner cleaner = cleaner(e)) {
760 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
760 >            List<Callable<String>> l = new ArrayList<>();
761              l.add(new StringTask());
762              l.add(new StringTask());
763              List<Future<String>> futures = e.invokeAll(l);
# Line 779 | Line 774 | public class ForkJoinPoolTest extends JS
774          ExecutorService e = new ForkJoinPool(1);
775          try (PoolCleaner cleaner = cleaner(e)) {
776              try {
777 <                e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
777 >                e.invokeAny(null, randomTimeout(), randomTimeUnit());
778                  shouldThrow();
779              } catch (NullPointerException success) {}
780          }
# Line 791 | Line 786 | public class ForkJoinPoolTest extends JS
786      public void testTimedInvokeAnyNullTimeUnit() throws Throwable {
787          ExecutorService e = new ForkJoinPool(1);
788          try (PoolCleaner cleaner = cleaner(e)) {
789 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
789 >            List<Callable<String>> l = new ArrayList<>();
790              l.add(new StringTask());
791              try {
792 <                e.invokeAny(l, MEDIUM_DELAY_MS, null);
792 >                e.invokeAny(l, randomTimeout(), null);
793                  shouldThrow();
794              } catch (NullPointerException success) {}
795          }
# Line 808 | Line 803 | public class ForkJoinPoolTest extends JS
803          try (PoolCleaner cleaner = cleaner(e)) {
804              try {
805                  e.invokeAny(new ArrayList<Callable<String>>(),
806 <                            MEDIUM_DELAY_MS, MILLISECONDS);
806 >                            randomTimeout(), randomTimeUnit());
807                  shouldThrow();
808              } catch (IllegalArgumentException success) {}
809          }
# Line 821 | Line 816 | public class ForkJoinPoolTest extends JS
816          CountDownLatch latch = new CountDownLatch(1);
817          ExecutorService e = new ForkJoinPool(1);
818          try (PoolCleaner cleaner = cleaner(e)) {
819 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
819 >            List<Callable<String>> l = new ArrayList<>();
820              l.add(latchAwaitingStringTask(latch));
821              l.add(null);
822              try {
823 <                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
823 >                e.invokeAny(l, randomTimeout(), randomTimeUnit());
824                  shouldThrow();
825              } catch (NullPointerException success) {}
826              latch.countDown();
# Line 839 | Line 834 | public class ForkJoinPoolTest extends JS
834          ExecutorService e = new ForkJoinPool(1);
835          try (PoolCleaner cleaner = cleaner(e)) {
836              long startTime = System.nanoTime();
837 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
837 >            List<Callable<String>> l = new ArrayList<>();
838              l.add(new NPETask());
839              try {
840                  e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
# Line 858 | Line 853 | public class ForkJoinPoolTest extends JS
853          ExecutorService e = new ForkJoinPool(1);
854          try (PoolCleaner cleaner = cleaner(e)) {
855              long startTime = System.nanoTime();
856 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
856 >            List<Callable<String>> l = new ArrayList<>();
857              l.add(new StringTask());
858              l.add(new StringTask());
859              String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
# Line 874 | Line 869 | public class ForkJoinPoolTest extends JS
869          ExecutorService e = new ForkJoinPool(1);
870          try (PoolCleaner cleaner = cleaner(e)) {
871              try {
872 <                e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
872 >                e.invokeAll(null, randomTimeout(), randomTimeUnit());
873                  shouldThrow();
874              } catch (NullPointerException success) {}
875          }
# Line 886 | Line 881 | public class ForkJoinPoolTest extends JS
881      public void testTimedInvokeAllNullTimeUnit() throws Throwable {
882          ExecutorService e = new ForkJoinPool(1);
883          try (PoolCleaner cleaner = cleaner(e)) {
884 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
884 >            List<Callable<String>> l = new ArrayList<>();
885              l.add(new StringTask());
886              try {
887 <                e.invokeAll(l, MEDIUM_DELAY_MS, null);
887 >                e.invokeAll(l, randomTimeout(), null);
888                  shouldThrow();
889              } catch (NullPointerException success) {}
890          }
891      }
892  
893      /**
894 <     * timed invokeAll(empty collection) returns empty collection
894 >     * timed invokeAll(empty collection) returns empty list
895       */
896      public void testTimedInvokeAll2() throws InterruptedException {
897          ExecutorService e = new ForkJoinPool(1);
898 +        final Collection<Callable<String>> emptyCollection
899 +            = Collections.emptyList();
900          try (PoolCleaner cleaner = cleaner(e)) {
901              List<Future<String>> r
902 <                = e.invokeAll(new ArrayList<Callable<String>>(),
903 <                              MEDIUM_DELAY_MS, MILLISECONDS);
902 >                = e.invokeAll(emptyCollection,
903 >                              randomTimeout(), randomTimeUnit());
904              assertTrue(r.isEmpty());
905          }
906      }
# Line 914 | Line 911 | public class ForkJoinPoolTest extends JS
911      public void testTimedInvokeAll3() throws InterruptedException {
912          ExecutorService e = new ForkJoinPool(1);
913          try (PoolCleaner cleaner = cleaner(e)) {
914 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
914 >            List<Callable<String>> l = new ArrayList<>();
915              l.add(new StringTask());
916              l.add(null);
917              try {
918 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
918 >                e.invokeAll(l, randomTimeout(), randomTimeUnit());
919                  shouldThrow();
920              } catch (NullPointerException success) {}
921          }
# Line 930 | Line 927 | public class ForkJoinPoolTest extends JS
927      public void testTimedInvokeAll4() throws Throwable {
928          ExecutorService e = new ForkJoinPool(1);
929          try (PoolCleaner cleaner = cleaner(e)) {
930 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
930 >            List<Callable<String>> l = new ArrayList<>();
931              l.add(new NPETask());
932              List<Future<String>> futures
933                  = e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
# Line 950 | Line 947 | public class ForkJoinPoolTest extends JS
947      public void testTimedInvokeAll5() throws Throwable {
948          ForkJoinPool e = new ForkJoinPool(1);
949          try (PoolCleaner cleaner = cleaner(e)) {
950 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
950 >            List<Callable<String>> l = new ArrayList<>();
951              l.add(new StringTask());
952              l.add(new StringTask());
953              List<Future<String>> futures

Diff Legend

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