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.23 by jsr166, Sat Sep 11 19:04:12 2010 UTC vs.
Revision 1.29 by jsr166, Fri Sep 17 16:49:25 2010 UTC

# Line 5 | Line 5
5   */
6  
7   import junit.framework.*;
8 < import java.util.*;
9 < import java.util.concurrent.Executor;
8 > import java.util.ArrayList;
9 > import java.util.Collection;
10 > import java.util.List;
11   import java.util.concurrent.Executors;
12   import java.util.concurrent.ExecutorService;
13   import java.util.concurrent.AbstractExecutorService;
# Line 19 | Line 20 | import java.util.concurrent.RejectedExec
20   import java.util.concurrent.ForkJoinPool;
21   import java.util.concurrent.ForkJoinTask;
22   import java.util.concurrent.ForkJoinWorkerThread;
22 – import java.util.concurrent.RecursiveAction;
23   import java.util.concurrent.RecursiveTask;
24   import java.util.concurrent.TimeUnit;
25 < import java.util.concurrent.locks.*;
26 < import java.security.*;
25 > import java.util.concurrent.locks.ReentrantLock;
26 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
27 > import java.security.AccessControlException;
28 > import java.security.Policy;
29 > import java.security.PrivilegedAction;
30 > import java.security.PrivilegedExceptionAction;
31  
32   public class ForkJoinPoolTest extends JSR166TestCase {
33      public static void main(String[] args) {
# Line 158 | Line 162 | public class ForkJoinPoolTest extends JS
162      public void testDefaultInitialState() {
163          ForkJoinPool p = new ForkJoinPool(1);
164          try {
165 <            assertTrue(p.getFactory() ==
166 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
165 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
166 >                       p.getFactory());
167              assertTrue(p.isQuiescent());
168              assertFalse(p.getAsyncMode());
169 <            assertTrue(p.getActiveThreadCount() == 0);
170 <            assertTrue(p.getStealCount() == 0);
171 <            assertTrue(p.getQueuedTaskCount() == 0);
172 <            assertTrue(p.getQueuedSubmissionCount() == 0);
169 >            assertEquals(0, p.getActiveThreadCount());
170 >            assertEquals(0, p.getStealCount());
171 >            assertEquals(0, p.getQueuedTaskCount());
172 >            assertEquals(0, p.getQueuedSubmissionCount());
173              assertFalse(p.hasQueuedSubmissions());
174              assertFalse(p.isShutdown());
175              assertFalse(p.isTerminating());
# Line 202 | Line 206 | public class ForkJoinPoolTest extends JS
206      public void testGetParallelism() {
207          ForkJoinPool p = new ForkJoinPool(1);
208          try {
209 <            assertTrue(p.getParallelism() == 1);
209 >            assertEquals(1, p.getParallelism());
210          } finally {
211              joinPool(p);
212          }
# Line 214 | Line 218 | public class ForkJoinPoolTest extends JS
218      public void testGetPoolSize() {
219          ForkJoinPool p = new ForkJoinPool(1);
220          try {
221 <            assertTrue(p.getActiveThreadCount() == 0);
221 >            assertEquals(0, p.getActiveThreadCount());
222              Future<String> future = p.submit(new StringTask());
223 <            assertTrue(p.getPoolSize() == 1);
223 >            assertEquals(1, p.getPoolSize());
224          } finally {
225              joinPool(p);
226          }
# Line 229 | Line 233 | public class ForkJoinPoolTest extends JS
233       * performs its defined action
234       */
235      public void testSetUncaughtExceptionHandler() throws InterruptedException {
236 <        MyHandler eh = new MyHandler();
237 <        ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(), eh, false);
238 <        try {
239 <            assert(eh == p.getUncaughtExceptionHandler());
240 <            p.execute(new FailingTask());
241 <            Thread.sleep(MEDIUM_DELAY_MS);
242 <            assertTrue(eh.catches > 0);
236 >        final CountDownLatch uehInvoked = new CountDownLatch(1);
237 >        final Thread.UncaughtExceptionHandler eh =
238 >            new Thread.UncaughtExceptionHandler() {
239 >                public void uncaughtException(Thread t, Throwable e) {
240 >                    uehInvoked.countDown();
241 >                }};
242 >        ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
243 >                                          eh, false);
244 >        try {
245 >            assertSame(eh, p.getUncaughtExceptionHandler());
246 >            p.execute(new FibTask(8));
247 >            assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
248          } finally {
249 <            p.shutdownNow();
249 >            p.shutdownNow(); // failure might have prevented processing task
250              joinPool(p);
251          }
252      }
# Line 251 | Line 260 | public class ForkJoinPoolTest extends JS
260          ForkJoinPool p = new ForkJoinPool(2);
261          try {
262              p.invoke(new FibTask(20));
263 <            assertTrue(p.getFactory() ==
264 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
263 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
264 >                       p.getFactory());
265              Thread.sleep(MEDIUM_DELAY_MS);
266              assertTrue(p.isQuiescent());
267              assertFalse(p.getAsyncMode());
268 <            assertTrue(p.getActiveThreadCount() == 0);
269 <            assertTrue(p.getQueuedTaskCount() == 0);
270 <            assertTrue(p.getQueuedSubmissionCount() == 0);
268 >            assertEquals(0, p.getActiveThreadCount());
269 >            assertEquals(0, p.getQueuedTaskCount());
270 >            assertEquals(0, p.getQueuedSubmissionCount());
271              assertFalse(p.hasQueuedSubmissions());
272              assertFalse(p.isShutdown());
273              assertFalse(p.isTerminating());
# Line 275 | Line 284 | public class ForkJoinPoolTest extends JS
284          ForkJoinPool p = new ForkJoinPool(1);
285          try {
286              ForkJoinTask<Integer> f = p.submit(new FibTask(8));
287 <            int r = f.get();
279 <            assertTrue(r == 21);
287 >            assertEquals(21, (int) f.get());
288          } finally {
289              joinPool(p);
290          }
# Line 290 | Line 298 | public class ForkJoinPoolTest extends JS
298          try {
299              p.shutdown();
300              assertTrue(p.isShutdown());
301 <            ForkJoinTask<Integer> f = p.submit(new FibTask(8));
302 <            shouldThrow();
303 <        } catch (RejectedExecutionException success) {
301 >            try {
302 >                ForkJoinTask<Integer> f = p.submit(new FibTask(8));
303 >                shouldThrow();
304 >            } catch (RejectedExecutionException success) {}
305          } finally {
306              joinPool(p);
307          }
# Line 308 | Line 317 | public class ForkJoinPoolTest extends JS
317              ManagedLocker locker = new ManagedLocker(lock);
318              ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
319              p.execute(f);
320 <            int r = f.get();
312 <            assertTrue(r == 832040);
320 >            assertEquals(832040, (int) f.get());
321          } finally {
322              p.shutdownNow(); // don't wait out shutdown
323          }
# Line 522 | Line 530 | public class ForkJoinPoolTest extends JS
530       */
531      public void testExecuteNullRunnable() {
532          ExecutorService e = new ForkJoinPool(1);
533 +        TrackedShortRunnable task = null;
534          try {
526 –            TrackedShortRunnable task = null;
535              Future<?> future = e.submit(task);
536              shouldThrow();
537          } catch (NullPointerException success) {
# Line 538 | Line 546 | public class ForkJoinPoolTest extends JS
546       */
547      public void testSubmitNullCallable() {
548          ExecutorService e = new ForkJoinPool(1);
549 +        StringTask t = null;
550          try {
542 –            StringTask t = null;
551              Future<String> future = e.submit(t);
552              shouldThrow();
553          } catch (NullPointerException success) {
# Line 550 | Line 558 | public class ForkJoinPoolTest extends JS
558  
559  
560      /**
561 <     * Blocking on submit(callable) throws InterruptedException if
554 <     * caller interrupted.
561 >     * submit(callable).get() throws InterruptedException if interrupted
562       */
563      public void testInterruptedSubmit() throws InterruptedException {
564 <        final ForkJoinPool p = new ForkJoinPool(1);
565 <
566 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
567 <            public void realRun() throws Throwable {
568 <                p.submit(new CheckedCallable<Object>() {
569 <                    public Object realCall() throws Throwable {
570 <                        try {
571 <                            Thread.sleep(MEDIUM_DELAY_MS);
572 <                        } catch (InterruptedException ok) {
573 <                        }
574 <                        return null;
575 <                    }}).get();
576 <            }});
577 <
578 <        t.start();
579 <        Thread.sleep(SHORT_DELAY_MS);
580 <        t.interrupt();
581 <        t.join();
582 <        p.shutdownNow();
583 <        joinPool(p);
564 >        final CountDownLatch submitted    = new CountDownLatch(1);
565 >        final CountDownLatch quittingTime = new CountDownLatch(1);
566 >        final ExecutorService p = new ForkJoinPool(1);
567 >        final Callable<Void> awaiter = new CheckedCallable<Void>() {
568 >            public Void realCall() throws InterruptedException {
569 >                assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS));
570 >                return null;
571 >            }};
572 >        try {
573 >            Thread t = new Thread(new CheckedInterruptedRunnable() {
574 >                public void realRun() throws Exception {
575 >                    Future<Void> future = p.submit(awaiter);
576 >                    submitted.countDown();
577 >                    future.get();
578 >                }});
579 >            t.start();
580 >            assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS));
581 >            t.interrupt();
582 >            t.join();
583 >        } finally {
584 >            quittingTime.countDown();
585 >            joinPool(p);
586 >        }
587      }
588  
589      /**
# Line 782 | Line 792 | public class ForkJoinPoolTest extends JS
792      public void testTimedInvokeAny1() throws Throwable {
793          ExecutorService e = new ForkJoinPool(1);
794          try {
795 <            e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
795 >            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
796              shouldThrow();
797          } catch (NullPointerException success) {
798          } finally {
# Line 813 | Line 823 | public class ForkJoinPoolTest extends JS
823          ExecutorService e = new ForkJoinPool(1);
824          try {
825              e.invokeAny(new ArrayList<Callable<String>>(),
826 <                        MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
826 >                        MEDIUM_DELAY_MS, MILLISECONDS);
827              shouldThrow();
828          } catch (IllegalArgumentException success) {
829          } finally {
# Line 831 | Line 841 | public class ForkJoinPoolTest extends JS
841          l.add(latchAwaitingStringTask(latch));
842          l.add(null);
843          try {
844 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
844 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
845              shouldThrow();
846          } catch (NullPointerException success) {
847          } finally {
# Line 848 | Line 858 | public class ForkJoinPoolTest extends JS
858          List<Callable<String>> l = new ArrayList<Callable<String>>();
859          l.add(new NPETask());
860          try {
861 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
861 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
862              shouldThrow();
863          } catch (ExecutionException success) {
864              assertTrue(success.getCause() instanceof NullPointerException);
# Line 866 | Line 876 | public class ForkJoinPoolTest extends JS
876              List<Callable<String>> l = new ArrayList<Callable<String>>();
877              l.add(new StringTask());
878              l.add(new StringTask());
879 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
879 >            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
880              assertSame(TEST_STRING, result);
881          } finally {
882              joinPool(e);
# Line 879 | Line 889 | public class ForkJoinPoolTest extends JS
889      public void testTimedInvokeAll1() throws Throwable {
890          ExecutorService e = new ForkJoinPool(1);
891          try {
892 <            e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
892 >            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
893              shouldThrow();
894          } catch (NullPointerException success) {
895          } finally {
# Line 911 | Line 921 | public class ForkJoinPoolTest extends JS
921          try {
922              List<Future<String>> r
923                  = e.invokeAll(new ArrayList<Callable<String>>(),
924 <                              MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
924 >                              MEDIUM_DELAY_MS, MILLISECONDS);
925              assertTrue(r.isEmpty());
926          } finally {
927              joinPool(e);
# Line 927 | Line 937 | public class ForkJoinPoolTest extends JS
937          l.add(new StringTask());
938          l.add(null);
939          try {
940 <            e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
940 >            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
941              shouldThrow();
942          } catch (NullPointerException success) {
943          } finally {
# Line 943 | Line 953 | public class ForkJoinPoolTest extends JS
953          List<Callable<String>> l = new ArrayList<Callable<String>>();
954          l.add(new NPETask());
955          List<Future<String>> futures
956 <            = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
956 >            = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
957          assertEquals(1, futures.size());
958          try {
959              futures.get(0).get();
# Line 965 | Line 975 | public class ForkJoinPoolTest extends JS
975              l.add(new StringTask());
976              l.add(new StringTask());
977              List<Future<String>> futures
978 <                = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
978 >                = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
979              assertEquals(2, futures.size());
980              for (Future<String> future : futures)
981                  assertSame(TEST_STRING, future.get());

Diff Legend

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