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.29 by jsr166, Fri Sep 17 16:49:25 2010 UTC vs.
Revision 1.35 by dl, Fri Nov 19 00:20:47 2010 UTC

# Line 259 | Line 259 | public class ForkJoinPoolTest extends JS
259      public void testisQuiescent() throws InterruptedException {
260          ForkJoinPool p = new ForkJoinPool(2);
261          try {
262 +            assertTrue(p.isQuiescent());
263              p.invoke(new FibTask(20));
264              assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
265                         p.getFactory());
266 <            Thread.sleep(MEDIUM_DELAY_MS);
266 >            Thread.sleep(SMALL_DELAY_MS);
267              assertTrue(p.isQuiescent());
268              assertFalse(p.getAsyncMode());
269              assertEquals(0, p.getActiveThreadCount());
# Line 315 | Line 316 | public class ForkJoinPoolTest extends JS
316          try {
317              ReentrantLock lock = new ReentrantLock();
318              ManagedLocker locker = new ManagedLocker(lock);
319 <            ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
319 >            ForkJoinTask<Integer> f = new LockingFibTask(20, locker, lock);
320              p.execute(f);
321 <            assertEquals(832040, (int) f.get());
321 >            assertEquals(6765, (int) f.get());
322          } finally {
323              p.shutdownNow(); // don't wait out shutdown
324          }
# Line 329 | Line 330 | public class ForkJoinPoolTest extends JS
330      public void testPollSubmission() {
331          SubFJP p = new SubFJP();
332          try {
333 <            ForkJoinTask a = p.submit(new MediumRunnable());
334 <            ForkJoinTask b = p.submit(new MediumRunnable());
335 <            ForkJoinTask c = p.submit(new MediumRunnable());
333 >            ForkJoinTask a = p.submit(new ShortRunnable());
334 >            ForkJoinTask b = p.submit(new ShortRunnable());
335 >            ForkJoinTask c = p.submit(new ShortRunnable());
336              ForkJoinTask r = p.pollSubmission();
337              assertTrue(r == a || r == b || r == c);
338              assertFalse(r.isDone());
# Line 346 | Line 347 | public class ForkJoinPoolTest extends JS
347      public void testDrainTasksTo() {
348          SubFJP p = new SubFJP();
349          try {
350 <            ForkJoinTask a = p.submit(new MediumRunnable());
351 <            ForkJoinTask b = p.submit(new MediumRunnable());
352 <            ForkJoinTask c = p.submit(new MediumRunnable());
350 >            ForkJoinTask a = p.submit(new ShortRunnable());
351 >            ForkJoinTask b = p.submit(new ShortRunnable());
352 >            ForkJoinTask c = p.submit(new ShortRunnable());
353              ArrayList<ForkJoinTask> al = new ArrayList();
354              p.drainTasksTo(al);
355              assertTrue(al.size() > 0);
# Line 370 | Line 371 | public class ForkJoinPoolTest extends JS
371      public void testExecuteRunnable() throws Throwable {
372          ExecutorService e = new ForkJoinPool(1);
373          try {
374 <            TrackedShortRunnable task = new TrackedShortRunnable();
375 <            assertFalse(task.done);
374 >            TrackedRunnable task = trackedRunnable(SHORT_DELAY_MS);
375 >            assertFalse(task.isDone());
376              Future<?> future = e.submit(task);
377 <            future.get();
378 <            assertTrue(task.done);
377 >            assertNull(future.get());
378 >            assertTrue(task.isDone());
379 >            assertFalse(future.isCancelled());
380          } finally {
381              joinPool(e);
382          }
# Line 388 | Line 390 | public class ForkJoinPoolTest extends JS
390          ExecutorService e = new ForkJoinPool(1);
391          try {
392              Future<String> future = e.submit(new StringTask());
393 <            String result = future.get();
394 <            assertSame(TEST_STRING, result);
393 >            assertSame(TEST_STRING, future.get());
394 >            assertTrue(future.isDone());
395 >            assertFalse(future.isCancelled());
396          } finally {
397              joinPool(e);
398          }
# Line 402 | Line 405 | public class ForkJoinPoolTest extends JS
405          ExecutorService e = new ForkJoinPool(1);
406          try {
407              Future<?> future = e.submit(new NoOpRunnable());
408 <            future.get();
408 >            assertNull(future.get());
409              assertTrue(future.isDone());
410 +            assertFalse(future.isCancelled());
411          } finally {
412              joinPool(e);
413          }
# Line 416 | Line 420 | public class ForkJoinPoolTest extends JS
420          ExecutorService e = new ForkJoinPool(1);
421          try {
422              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
423 <            String result = future.get();
424 <            assertSame(TEST_STRING, result);
423 >            assertSame(TEST_STRING, future.get());
424 >            assertTrue(future.isDone());
425 >            assertFalse(future.isCancelled());
426          } finally {
427              joinPool(e);
428          }
429      }
430  
426 –
431      /**
432 <     * A submitted privileged action to completion
432 >     * A submitted privileged action runs to completion
433       */
434 <    public void testSubmitPrivilegedAction() throws Throwable {
435 <        Policy savedPolicy = null;
436 <        try {
437 <            savedPolicy = Policy.getPolicy();
434 <            AdjustablePolicy policy = new AdjustablePolicy();
435 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
436 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
437 <            Policy.setPolicy(policy);
438 <        } catch (AccessControlException ok) {
439 <            return;
440 <        }
441 <
442 <        try {
443 <            ExecutorService e = new ForkJoinPool(1);
444 <            try {
434 >    public void testSubmitPrivilegedAction() throws Exception {
435 >        Runnable r = new CheckedRunnable() {
436 >            public void realRun() throws Exception {
437 >                ExecutorService e = new ForkJoinPool(1);
438                  Future future = e.submit(Executors.callable(new PrivilegedAction() {
439                      public Object run() {
440                          return TEST_STRING;
441                      }}));
442  
443 <                Object result = future.get();
444 <                assertSame(TEST_STRING, result);
445 <            } finally {
446 <                joinPool(e);
447 <            }
455 <        } finally {
456 <            Policy.setPolicy(savedPolicy);
457 <        }
443 >                assertSame(TEST_STRING, future.get());
444 >            }};
445 >
446 >        runWithPermissions(r,
447 >                           new RuntimePermission("modifyThread"));
448      }
449  
450      /**
451 <     * A submitted a privileged exception action runs to completion
451 >     * A submitted privileged exception action runs to completion
452       */
453 <    public void testSubmitPrivilegedExceptionAction() throws Throwable {
454 <        Policy savedPolicy = null;
455 <        try {
456 <            savedPolicy = Policy.getPolicy();
467 <            AdjustablePolicy policy = new AdjustablePolicy();
468 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
469 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
470 <            Policy.setPolicy(policy);
471 <        } catch (AccessControlException ok) {
472 <            return;
473 <        }
474 <
475 <        try {
476 <            ExecutorService e = new ForkJoinPool(1);
477 <            try {
453 >    public void testSubmitPrivilegedExceptionAction() throws Exception {
454 >        Runnable r = new CheckedRunnable() {
455 >            public void realRun() throws Exception {
456 >                ExecutorService e = new ForkJoinPool(1);
457                  Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
458                      public Object run() {
459                          return TEST_STRING;
460                      }}));
461  
462 <                Object result = future.get();
463 <                assertSame(TEST_STRING, result);
464 <            } finally {
465 <                joinPool(e);
487 <            }
488 <        } finally {
489 <            Policy.setPolicy(savedPolicy);
490 <        }
462 >                assertSame(TEST_STRING, future.get());
463 >            }};
464 >
465 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
466      }
467  
468      /**
469       * A submitted failed privileged exception action reports exception
470       */
471 <    public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
472 <        Policy savedPolicy = null;
473 <        try {
474 <            savedPolicy = Policy.getPolicy();
500 <            AdjustablePolicy policy = new AdjustablePolicy();
501 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
502 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
503 <            Policy.setPolicy(policy);
504 <        } catch (AccessControlException ok) {
505 <            return;
506 <        }
507 <
508 <        try {
509 <            ExecutorService e = new ForkJoinPool(1);
510 <            try {
471 >    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
472 >        Runnable r = new CheckedRunnable() {
473 >            public void realRun() throws Exception {
474 >                ExecutorService e = new ForkJoinPool(1);
475                  Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
476                      public Object run() throws Exception {
477                          throw new IndexOutOfBoundsException();
478                      }}));
479  
480 <                Object result = future.get();
481 <                shouldThrow();
482 <            } catch (ExecutionException success) {
483 <                assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
484 <            } finally {
485 <                joinPool(e);
486 <            }
487 <        } finally {
524 <            Policy.setPolicy(savedPolicy);
525 <        }
480 >                try {
481 >                    future.get();
482 >                    shouldThrow();
483 >                } catch (ExecutionException success) {
484 >                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
485 >                }}};
486 >
487 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
488      }
489  
490      /**
# Line 530 | Line 492 | public class ForkJoinPoolTest extends JS
492       */
493      public void testExecuteNullRunnable() {
494          ExecutorService e = new ForkJoinPool(1);
533 –        TrackedShortRunnable task = null;
495          try {
496 <            Future<?> future = e.submit(task);
496 >            Future<?> future = e.submit((Runnable) null);
497              shouldThrow();
498          } catch (NullPointerException success) {
499          } finally {
# Line 546 | Line 507 | public class ForkJoinPoolTest extends JS
507       */
508      public void testSubmitNullCallable() {
509          ExecutorService e = new ForkJoinPool(1);
549 –        StringTask t = null;
510          try {
511 <            Future<String> future = e.submit(t);
511 >            Future<String> future = e.submit((Callable) null);
512              shouldThrow();
513          } catch (NullPointerException success) {
514          } finally {

Diff Legend

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