--- jsr166/src/test/tck/JSR166TestCase.java 2010/09/01 06:41:55 1.51 +++ jsr166/src/test/tck/JSR166TestCase.java 2011/05/29 14:18:52 1.85 @@ -1,17 +1,32 @@ /* * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at - * http://creativecommons.org/licenses/publicdomain + * http://creativecommons.org/publicdomain/zero/1.0/ * Other contributors include Andrew Wright, Jeffrey Hayes, * Pat Fisher, Mike Judd. */ import junit.framework.*; -import java.util.*; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.Arrays; +import java.util.Date; +import java.util.NoSuchElementException; +import java.util.PropertyPermission; import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; import static java.util.concurrent.TimeUnit.MILLISECONDS; -import java.io.*; -import java.security.*; +import static java.util.concurrent.TimeUnit.NANOSECONDS; +import java.security.CodeSource; +import java.security.Permission; +import java.security.PermissionCollection; +import java.security.Permissions; +import java.security.Policy; +import java.security.ProtectionDomain; +import java.security.SecurityPermission; /** * Base class for JSR166 Junit TCK tests. Defines some constants, @@ -90,6 +105,42 @@ public class JSR166TestCase extends Test private static final boolean useSecurityManager = Boolean.getBoolean("jsr166.useSecurityManager"); + protected static final boolean expensiveTests = + Boolean.getBoolean("jsr166.expensiveTests"); + + /** + * If true, report on stdout all "slow" tests, that is, ones that + * take more than profileThreshold milliseconds to execute. + */ + private static final boolean profileTests = + Boolean.getBoolean("jsr166.profileTests"); + + /** + * The number of milliseconds that tests are permitted for + * execution without being reported, when profileTests is set. + */ + private static final long profileThreshold = + Long.getLong("jsr166.profileThreshold", 100); + + protected void runTest() throws Throwable { + if (profileTests) + runTestProfiled(); + else + super.runTest(); + } + + protected void runTestProfiled() throws Throwable { + long t0 = System.nanoTime(); + try { + super.runTest(); + } finally { + long elapsedMillis = + (System.nanoTime() - t0) / (1000L * 1000L); + if (elapsedMillis >= profileThreshold) + System.out.printf("%n%s: %d%n", toString(), elapsedMillis); + } + } + /** * Runs all JSR166 unit tests using junit.textui.TestRunner */ @@ -99,9 +150,8 @@ public class JSR166TestCase extends Test Policy.setPolicy(permissivePolicy()); System.setSecurityManager(new SecurityManager()); } - int iters = 1; - if (args.length > 0) - iters = Integer.parseInt(args[0]); + int iters = (args.length == 0) ? 1 : Integer.parseInt(args[0]); + Test s = suite(); for (int i = 0; i < iters; ++i) { junit.textui.TestRunner.run(s); @@ -111,78 +161,88 @@ public class JSR166TestCase extends Test System.exit(0); } + public static TestSuite newTestSuite(Object... suiteOrClasses) { + TestSuite suite = new TestSuite(); + for (Object suiteOrClass : suiteOrClasses) { + if (suiteOrClass instanceof TestSuite) + suite.addTest((TestSuite) suiteOrClass); + else if (suiteOrClass instanceof Class) + suite.addTest(new TestSuite((Class) suiteOrClass)); + else + throw new ClassCastException("not a test suite or class"); + } + return suite; + } + /** - * Collects all JSR166 unit tests as one suite + * Collects all JSR166 unit tests as one suite. */ public static Test suite() { - TestSuite suite = new TestSuite("JSR166 Unit Tests"); - - suite.addTest(new TestSuite(ForkJoinPoolTest.class)); - suite.addTest(new TestSuite(ForkJoinTaskTest.class)); - suite.addTest(new TestSuite(RecursiveActionTest.class)); - suite.addTest(new TestSuite(RecursiveTaskTest.class)); - suite.addTest(new TestSuite(LinkedTransferQueueTest.class)); - suite.addTest(new TestSuite(PhaserTest.class)); - suite.addTest(new TestSuite(ThreadLocalRandomTest.class)); - suite.addTest(new TestSuite(AbstractExecutorServiceTest.class)); - suite.addTest(new TestSuite(AbstractQueueTest.class)); - suite.addTest(new TestSuite(AbstractQueuedSynchronizerTest.class)); - suite.addTest(new TestSuite(AbstractQueuedLongSynchronizerTest.class)); - suite.addTest(new TestSuite(ArrayBlockingQueueTest.class)); - suite.addTest(new TestSuite(ArrayDequeTest.class)); - suite.addTest(new TestSuite(AtomicBooleanTest.class)); - suite.addTest(new TestSuite(AtomicIntegerArrayTest.class)); - suite.addTest(new TestSuite(AtomicIntegerFieldUpdaterTest.class)); - suite.addTest(new TestSuite(AtomicIntegerTest.class)); - suite.addTest(new TestSuite(AtomicLongArrayTest.class)); - suite.addTest(new TestSuite(AtomicLongFieldUpdaterTest.class)); - suite.addTest(new TestSuite(AtomicLongTest.class)); - suite.addTest(new TestSuite(AtomicMarkableReferenceTest.class)); - suite.addTest(new TestSuite(AtomicReferenceArrayTest.class)); - suite.addTest(new TestSuite(AtomicReferenceFieldUpdaterTest.class)); - suite.addTest(new TestSuite(AtomicReferenceTest.class)); - suite.addTest(new TestSuite(AtomicStampedReferenceTest.class)); - suite.addTest(new TestSuite(ConcurrentHashMapTest.class)); - suite.addTest(new TestSuite(ConcurrentLinkedDequeTest.class)); - suite.addTest(new TestSuite(ConcurrentLinkedQueueTest.class)); - suite.addTest(new TestSuite(ConcurrentSkipListMapTest.class)); - suite.addTest(new TestSuite(ConcurrentSkipListSubMapTest.class)); - suite.addTest(new TestSuite(ConcurrentSkipListSetTest.class)); - suite.addTest(new TestSuite(ConcurrentSkipListSubSetTest.class)); - suite.addTest(new TestSuite(CopyOnWriteArrayListTest.class)); - suite.addTest(new TestSuite(CopyOnWriteArraySetTest.class)); - suite.addTest(new TestSuite(CountDownLatchTest.class)); - suite.addTest(new TestSuite(CyclicBarrierTest.class)); - suite.addTest(new TestSuite(DelayQueueTest.class)); - suite.addTest(new TestSuite(EntryTest.class)); - suite.addTest(new TestSuite(ExchangerTest.class)); - suite.addTest(new TestSuite(ExecutorsTest.class)); - suite.addTest(new TestSuite(ExecutorCompletionServiceTest.class)); - suite.addTest(new TestSuite(FutureTaskTest.class)); - suite.addTest(new TestSuite(LinkedBlockingDequeTest.class)); - suite.addTest(new TestSuite(LinkedBlockingQueueTest.class)); - suite.addTest(new TestSuite(LinkedListTest.class)); - suite.addTest(new TestSuite(LockSupportTest.class)); - suite.addTest(new TestSuite(PriorityBlockingQueueTest.class)); - suite.addTest(new TestSuite(PriorityQueueTest.class)); - suite.addTest(new TestSuite(ReentrantLockTest.class)); - suite.addTest(new TestSuite(ReentrantReadWriteLockTest.class)); - suite.addTest(new TestSuite(ScheduledExecutorTest.class)); - suite.addTest(new TestSuite(ScheduledExecutorSubclassTest.class)); - suite.addTest(new TestSuite(SemaphoreTest.class)); - suite.addTest(new TestSuite(SynchronousQueueTest.class)); - suite.addTest(new TestSuite(SystemTest.class)); - suite.addTest(new TestSuite(ThreadLocalTest.class)); - suite.addTest(new TestSuite(ThreadPoolExecutorTest.class)); - suite.addTest(new TestSuite(ThreadPoolExecutorSubclassTest.class)); - suite.addTest(new TestSuite(ThreadTest.class)); - suite.addTest(new TestSuite(TimeUnitTest.class)); - suite.addTest(new TestSuite(TreeMapTest.class)); - suite.addTest(new TestSuite(TreeSetTest.class)); - suite.addTest(new TestSuite(TreeSubMapTest.class)); - suite.addTest(new TestSuite(TreeSubSetTest.class)); - - return suite; + return newTestSuite( + ForkJoinPoolTest.suite(), + ForkJoinTaskTest.suite(), + RecursiveActionTest.suite(), + RecursiveTaskTest.suite(), + LinkedTransferQueueTest.suite(), + PhaserTest.suite(), + ThreadLocalRandomTest.suite(), + AbstractExecutorServiceTest.suite(), + AbstractQueueTest.suite(), + AbstractQueuedSynchronizerTest.suite(), + AbstractQueuedLongSynchronizerTest.suite(), + ArrayBlockingQueueTest.suite(), + ArrayDequeTest.suite(), + AtomicBooleanTest.suite(), + AtomicIntegerArrayTest.suite(), + AtomicIntegerFieldUpdaterTest.suite(), + AtomicIntegerTest.suite(), + AtomicLongArrayTest.suite(), + AtomicLongFieldUpdaterTest.suite(), + AtomicLongTest.suite(), + AtomicMarkableReferenceTest.suite(), + AtomicReferenceArrayTest.suite(), + AtomicReferenceFieldUpdaterTest.suite(), + AtomicReferenceTest.suite(), + AtomicStampedReferenceTest.suite(), + ConcurrentHashMapTest.suite(), + ConcurrentLinkedDequeTest.suite(), + ConcurrentLinkedQueueTest.suite(), + ConcurrentSkipListMapTest.suite(), + ConcurrentSkipListSubMapTest.suite(), + ConcurrentSkipListSetTest.suite(), + ConcurrentSkipListSubSetTest.suite(), + CopyOnWriteArrayListTest.suite(), + CopyOnWriteArraySetTest.suite(), + CountDownLatchTest.suite(), + CyclicBarrierTest.suite(), + DelayQueueTest.suite(), + EntryTest.suite(), + ExchangerTest.suite(), + ExecutorsTest.suite(), + ExecutorCompletionServiceTest.suite(), + FutureTaskTest.suite(), + LinkedBlockingDequeTest.suite(), + LinkedBlockingQueueTest.suite(), + LinkedListTest.suite(), + LockSupportTest.suite(), + PriorityBlockingQueueTest.suite(), + PriorityQueueTest.suite(), + ReentrantLockTest.suite(), + ReentrantReadWriteLockTest.suite(), + ScheduledExecutorTest.suite(), + ScheduledExecutorSubclassTest.suite(), + SemaphoreTest.suite(), + SynchronousQueueTest.suite(), + SystemTest.suite(), + ThreadLocalTest.suite(), + ThreadPoolExecutorTest.suite(), + ThreadPoolExecutorSubclassTest.suite(), + ThreadTest.suite(), + TimeUnitTest.suite(), + TreeMapTest.suite(), + TreeSetTest.suite(), + TreeSubMapTest.suite(), + TreeSubSetTest.suite()); } @@ -200,140 +260,245 @@ public class JSR166TestCase extends Test return 50; } - /** * Sets delays as multiples of SHORT_DELAY. */ protected void setDelays() { SHORT_DELAY_MS = getShortDelay(); - SMALL_DELAY_MS = SHORT_DELAY_MS * 5; + SMALL_DELAY_MS = SHORT_DELAY_MS * 5; MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10; - LONG_DELAY_MS = SHORT_DELAY_MS * 50; + LONG_DELAY_MS = SHORT_DELAY_MS * 200; + } + + /** + * Returns a timeout in milliseconds to be used in tests that + * verify that operations block or time out. + */ + long timeoutMillis() { + return SHORT_DELAY_MS / 4; } /** - * Flag set true if any threadAssert methods fail + * Returns a new Date instance representing a time delayMillis + * milliseconds in the future. */ - volatile boolean threadFailed; + Date delayedDate(long delayMillis) { + return new Date(System.currentTimeMillis() + delayMillis); + } /** - * Initializes test to indicate that no thread assertions have failed + * The first exception encountered if any threadAssertXXX method fails. */ + private final AtomicReference threadFailure + = new AtomicReference(null); + + /** + * Records an exception so that it can be rethrown later in the test + * harness thread, triggering a test case failure. Only the first + * failure is recorded; subsequent calls to this method from within + * the same test have no effect. + */ + public void threadRecordFailure(Throwable t) { + threadFailure.compareAndSet(null, t); + } + public void setUp() { setDelays(); - threadFailed = false; } /** - * Triggers test case failure if any thread assertions have failed - */ - public void tearDown() { - assertFalse(threadFailed); + * Extra checks that get done for all test cases. + * + * Triggers test case failure if any thread assertions have failed, + * by rethrowing, in the test harness thread, any exception recorded + * earlier by threadRecordFailure. + * + * Triggers test case failure if interrupt status is set in the main thread. + */ + public void tearDown() throws Exception { + Throwable t = threadFailure.getAndSet(null); + if (t != null) { + if (t instanceof Error) + throw (Error) t; + else if (t instanceof RuntimeException) + throw (RuntimeException) t; + else if (t instanceof Exception) + throw (Exception) t; + else { + AssertionFailedError afe = + new AssertionFailedError(t.toString()); + afe.initCause(t); + throw afe; + } + } + + if (Thread.interrupted()) + throw new AssertionFailedError("interrupt status set in main thread"); } /** - * Fail, also setting status to indicate current testcase should fail + * Just like fail(reason), but additionally recording (using + * threadRecordFailure) any AssertionFailedError thrown, so that + * the current testcase will fail. */ public void threadFail(String reason) { - threadFailed = true; - fail(reason); + try { + fail(reason); + } catch (AssertionFailedError t) { + threadRecordFailure(t); + fail(reason); + } } /** - * If expression not true, set status to indicate current testcase - * should fail + * Just like assertTrue(b), but additionally recording (using + * threadRecordFailure) any AssertionFailedError thrown, so that + * the current testcase will fail. */ public void threadAssertTrue(boolean b) { - if (!b) { - threadFailed = true; + try { assertTrue(b); + } catch (AssertionFailedError t) { + threadRecordFailure(t); + throw t; } } /** - * If expression not false, set status to indicate current testcase - * should fail + * Just like assertFalse(b), but additionally recording (using + * threadRecordFailure) any AssertionFailedError thrown, so that + * the current testcase will fail. */ public void threadAssertFalse(boolean b) { - if (b) { - threadFailed = true; + try { assertFalse(b); + } catch (AssertionFailedError t) { + threadRecordFailure(t); + throw t; } } /** - * If argument not null, set status to indicate current testcase - * should fail + * Just like assertNull(x), but additionally recording (using + * threadRecordFailure) any AssertionFailedError thrown, so that + * the current testcase will fail. */ public void threadAssertNull(Object x) { - if (x != null) { - threadFailed = true; + try { assertNull(x); + } catch (AssertionFailedError t) { + threadRecordFailure(t); + throw t; } } /** - * If arguments not equal, set status to indicate current testcase - * should fail + * Just like assertEquals(x, y), but additionally recording (using + * threadRecordFailure) any AssertionFailedError thrown, so that + * the current testcase will fail. */ public void threadAssertEquals(long x, long y) { - if (x != y) { - threadFailed = true; + try { assertEquals(x, y); + } catch (AssertionFailedError t) { + threadRecordFailure(t); + throw t; } } /** - * If arguments not equal, set status to indicate current testcase - * should fail + * Just like assertEquals(x, y), but additionally recording (using + * threadRecordFailure) any AssertionFailedError thrown, so that + * the current testcase will fail. */ public void threadAssertEquals(Object x, Object y) { - if (x != y && (x == null || !x.equals(y))) { - threadFailed = true; + try { assertEquals(x, y); + } catch (AssertionFailedError t) { + threadRecordFailure(t); + throw t; + } catch (Throwable t) { + threadUnexpectedException(t); } } /** - * threadFail with message "should throw exception" + * Just like assertSame(x, y), but additionally recording (using + * threadRecordFailure) any AssertionFailedError thrown, so that + * the current testcase will fail. + */ + public void threadAssertSame(Object x, Object y) { + try { + assertSame(x, y); + } catch (AssertionFailedError t) { + threadRecordFailure(t); + throw t; + } + } + + /** + * Calls threadFail with message "should throw exception". */ public void threadShouldThrow() { - threadFailed = true; - fail("should throw exception"); + threadFail("should throw exception"); } /** - * threadFail with message "should throw" + exceptionName + * Calls threadFail with message "should throw" + exceptionName. */ public void threadShouldThrow(String exceptionName) { - threadFailed = true; - fail("should throw " + exceptionName); + threadFail("should throw " + exceptionName); } /** - * threadFail with message "Unexpected exception" + * Records the given exception using {@link #threadRecordFailure}, + * then rethrows the exception, wrapping it in an + * AssertionFailedError if necessary. */ - public void threadUnexpectedException() { - threadFailed = true; - fail("Unexpected exception"); + public void threadUnexpectedException(Throwable t) { + threadRecordFailure(t); + t.printStackTrace(); + if (t instanceof RuntimeException) + throw (RuntimeException) t; + else if (t instanceof Error) + throw (Error) t; + else { + AssertionFailedError afe = + new AssertionFailedError("unexpected exception: " + t); + afe.initCause(t); + throw afe; + } } /** - * threadFail with message "Unexpected exception", with argument + * Delays, via Thread.sleep, for the given millisecond delay, but + * if the sleep is shorter than specified, may re-sleep or yield + * until time elapses. */ - public void threadUnexpectedException(Throwable ex) { - threadFailed = true; - ex.printStackTrace(); - fail("Unexpected exception: " + ex); + static void delay(long millis) throws InterruptedException { + long startTime = System.nanoTime(); + long ns = millis * 1000 * 1000; + for (;;) { + if (millis > 0L) + Thread.sleep(millis); + else // too short to sleep + Thread.yield(); + long d = ns - (System.nanoTime() - startTime); + if (d > 0L) + millis = d / (1000 * 1000); + else + break; + } } /** - * Wait out termination of a thread pool or fail doing so + * Waits out termination of a thread pool or fails doing so. */ - public void joinPool(ExecutorService exec) { + void joinPool(ExecutorService exec) { try { exec.shutdown(); - assertTrue(exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue("ExecutorService did not terminate in a timely manner", + exec.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS)); } catch (SecurityException ok) { // Allowed in case test doesn't have privs } catch (InterruptedException ie) { @@ -341,36 +506,63 @@ public class JSR166TestCase extends Test } } + /** + * Checks that thread does not terminate within the default + * millisecond delay of {@code timeoutMillis()}. + */ + void assertThreadStaysAlive(Thread thread) { + assertThreadStaysAlive(thread, timeoutMillis()); + } /** - * fail with message "should throw exception" + * Checks that thread does not terminate within the given millisecond delay. */ - public void shouldThrow() { - fail("Should throw exception"); + void assertThreadStaysAlive(Thread thread, long millis) { + try { + // No need to optimize the failing case via Thread.join. + delay(millis); + assertTrue(thread.isAlive()); + } catch (InterruptedException ie) { + fail("Unexpected InterruptedException"); + } } /** - * fail with message "should throw " + exceptionName + * Checks that future.get times out, with the default timeout of + * {@code timeoutMillis()}. */ - public void shouldThrow(String exceptionName) { - fail("Should throw " + exceptionName); + void assertFutureTimesOut(Future future) { + assertFutureTimesOut(future, timeoutMillis()); } /** - * fail with message "Unexpected exception" + * Checks that future.get times out, with the given millisecond timeout. */ - public void unexpectedException() { - fail("Unexpected exception"); + void assertFutureTimesOut(Future future, long timeoutMillis) { + long startTime = System.nanoTime(); + try { + future.get(timeoutMillis, MILLISECONDS); + shouldThrow(); + } catch (TimeoutException success) { + } catch (Exception e) { + threadUnexpectedException(e); + } finally { future.cancel(true); } + assertTrue(millisElapsedSince(startTime) >= timeoutMillis); } /** - * fail with message "Unexpected exception", with argument + * Fails with message "should throw exception". */ - public void unexpectedException(Throwable ex) { - ex.printStackTrace(); - fail("Unexpected exception: " + ex); + public void shouldThrow() { + fail("Should throw exception"); } + /** + * Fails with message "should throw " + exceptionName. + */ + public void shouldThrow(String exceptionName) { + fail("Should throw " + exceptionName); + } /** * The number of elements to place in collections, arrays, etc. @@ -483,24 +675,97 @@ public class JSR166TestCase extends Test } /** - * Sleep until the timeout has elapsed, or interrupted. - * Does NOT throw InterruptedException. + * Sleeps until the given time has elapsed. + * Throws AssertionFailedError if interrupted. */ - void sleepTillInterrupted(long timeoutMillis) { + void sleep(long millis) { try { - Thread.sleep(timeoutMillis); - } catch (InterruptedException wakeup) {} + delay(millis); + } catch (InterruptedException ie) { + AssertionFailedError afe = + new AssertionFailedError("Unexpected InterruptedException"); + afe.initCause(ie); + throw afe; + } + } + + /** + * Waits up to the specified number of milliseconds for the given + * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING. + */ + void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) { + long timeoutNanos = timeoutMillis * 1000L * 1000L; + long t0 = System.nanoTime(); + for (;;) { + Thread.State s = thread.getState(); + if (s == Thread.State.BLOCKED || + s == Thread.State.WAITING || + s == Thread.State.TIMED_WAITING) + return; + else if (s == Thread.State.TERMINATED) + fail("Unexpected thread termination"); + else if (System.nanoTime() - t0 > timeoutNanos) { + threadAssertTrue(thread.isAlive()); + return; + } + Thread.yield(); + } + } + + /** + * Waits up to LONG_DELAY_MS for the given thread to enter a wait + * state: BLOCKED, WAITING, or TIMED_WAITING. + */ + void waitForThreadToEnterWaitState(Thread thread) { + waitForThreadToEnterWaitState(thread, LONG_DELAY_MS); } /** - * Returns a new started Thread running the given runnable. + * Returns the number of milliseconds since time given by + * startNanoTime, which must have been previously returned from a + * call to {@link System.nanoTime()}. + */ + long millisElapsedSince(long startNanoTime) { + return NANOSECONDS.toMillis(System.nanoTime() - startNanoTime); + } + + /** + * Returns a new started daemon Thread running the given runnable. */ Thread newStartedThread(Runnable runnable) { Thread t = new Thread(runnable); + t.setDaemon(true); t.start(); return t; } + /** + * Waits for the specified time (in milliseconds) for the thread + * to terminate (using {@link Thread#join(long)}), else interrupts + * the thread (in the hope that it may terminate later) and fails. + */ + void awaitTermination(Thread t, long timeoutMillis) { + try { + t.join(timeoutMillis); + } catch (InterruptedException ie) { + threadUnexpectedException(ie); + } finally { + if (t.getState() != Thread.State.TERMINATED) { + t.interrupt(); + fail("Test timed out"); + } + } + } + + /** + * Waits for LONG_DELAY_MS milliseconds for the thread to + * terminate (using {@link Thread#join(long)}), else interrupts + * the thread (in the hope that it may terminate later) and fails. + */ + void awaitTermination(Thread t) { + awaitTermination(t, LONG_DELAY_MS); + } + // Some convenient Runnable classes public abstract class CheckedRunnable implements Runnable { @@ -563,6 +828,7 @@ public class JSR166TestCase extends Test realRun(); threadShouldThrow("InterruptedException"); } catch (InterruptedException success) { + threadAssertFalse(Thread.interrupted()); } catch (Throwable t) { threadUnexpectedException(t); } @@ -577,12 +843,13 @@ public class JSR166TestCase extends Test return realCall(); } catch (Throwable t) { threadUnexpectedException(t); + return null; } - return null; } } - public abstract class CheckedInterruptedCallable implements Callable { + public abstract class CheckedInterruptedCallable + implements Callable { protected abstract T realCall() throws Throwable; public final T call() { @@ -591,6 +858,7 @@ public class JSR166TestCase extends Test threadShouldThrow("InterruptedException"); return result; } catch (InterruptedException success) { + threadAssertFalse(Thread.interrupted()); } catch (Throwable t) { threadUnexpectedException(t); } @@ -614,7 +882,7 @@ public class JSR166TestCase extends Test public Callable latchAwaitingStringTask(final CountDownLatch latch) { return new CheckedCallable() { - public String realCall() { + protected String realCall() { try { latch.await(); } catch (InterruptedException quittingTime) {} @@ -622,6 +890,40 @@ public class JSR166TestCase extends Test }}; } + public Runnable awaiter(final CountDownLatch latch) { + return new CheckedRunnable() { + public void realRun() throws InterruptedException { + await(latch); + }}; + } + + public void await(CountDownLatch latch) { + try { + assertTrue(latch.await(LONG_DELAY_MS, MILLISECONDS)); + } catch (Throwable t) { + threadUnexpectedException(t); + } + } + +// /** +// * Spin-waits up to LONG_DELAY_MS until flag becomes true. +// */ +// public void await(AtomicBoolean flag) { +// await(flag, LONG_DELAY_MS); +// } + +// /** +// * Spin-waits up to the specified timeout until flag becomes true. +// */ +// public void await(AtomicBoolean flag, long timeoutMillis) { +// long startTime = System.nanoTime(); +// while (!flag.get()) { +// if (millisElapsedSince(startTime) > timeoutMillis) +// throw new AssertionFailedError("timed out"); +// Thread.yield(); +// } +// } + public static class NPETask implements Callable { public String call() { throw new NullPointerException(); } } @@ -632,59 +934,62 @@ public class JSR166TestCase extends Test public class ShortRunnable extends CheckedRunnable { protected void realRun() throws Throwable { - Thread.sleep(SHORT_DELAY_MS); + delay(SHORT_DELAY_MS); } } public class ShortInterruptedRunnable extends CheckedInterruptedRunnable { protected void realRun() throws InterruptedException { - Thread.sleep(SHORT_DELAY_MS); + delay(SHORT_DELAY_MS); } } public class SmallRunnable extends CheckedRunnable { protected void realRun() throws Throwable { - Thread.sleep(SMALL_DELAY_MS); + delay(SMALL_DELAY_MS); } } public class SmallPossiblyInterruptedRunnable extends CheckedRunnable { protected void realRun() { try { - Thread.sleep(SMALL_DELAY_MS); + delay(SMALL_DELAY_MS); } catch (InterruptedException ok) {} } } public class SmallCallable extends CheckedCallable { protected Object realCall() throws InterruptedException { - Thread.sleep(SMALL_DELAY_MS); + delay(SMALL_DELAY_MS); return Boolean.TRUE; } } - public class SmallInterruptedRunnable extends CheckedInterruptedRunnable { - protected void realRun() throws InterruptedException { - Thread.sleep(SMALL_DELAY_MS); - } - } - public class MediumRunnable extends CheckedRunnable { protected void realRun() throws Throwable { - Thread.sleep(MEDIUM_DELAY_MS); + delay(MEDIUM_DELAY_MS); } } public class MediumInterruptedRunnable extends CheckedInterruptedRunnable { protected void realRun() throws InterruptedException { - Thread.sleep(MEDIUM_DELAY_MS); + delay(MEDIUM_DELAY_MS); } } + public Runnable possiblyInterruptedRunnable(final long timeoutMillis) { + return new CheckedRunnable() { + protected void realRun() { + try { + delay(timeoutMillis); + } catch (InterruptedException ok) {} + }}; + } + public class MediumPossiblyInterruptedRunnable extends CheckedRunnable { protected void realRun() { try { - Thread.sleep(MEDIUM_DELAY_MS); + delay(MEDIUM_DELAY_MS); } catch (InterruptedException ok) {} } } @@ -692,7 +997,7 @@ public class JSR166TestCase extends Test public class LongPossiblyInterruptedRunnable extends CheckedRunnable { protected void realRun() { try { - Thread.sleep(LONG_DELAY_MS); + delay(LONG_DELAY_MS); } catch (InterruptedException ok) {} } } @@ -706,11 +1011,38 @@ public class JSR166TestCase extends Test } } + public interface TrackedRunnable extends Runnable { + boolean isDone(); + } + + public static TrackedRunnable trackedRunnable(final long timeoutMillis) { + return new TrackedRunnable() { + private volatile boolean done = false; + public boolean isDone() { return done; } + public void run() { + try { + delay(timeoutMillis); + done = true; + } catch (InterruptedException ok) {} + } + }; + } + public static class TrackedShortRunnable implements Runnable { public volatile boolean done = false; public void run() { try { - Thread.sleep(SMALL_DELAY_MS); + delay(SHORT_DELAY_MS); + done = true; + } catch (InterruptedException ok) {} + } + } + + public static class TrackedSmallRunnable implements Runnable { + public volatile boolean done = false; + public void run() { + try { + delay(SMALL_DELAY_MS); done = true; } catch (InterruptedException ok) {} } @@ -720,7 +1052,7 @@ public class JSR166TestCase extends Test public volatile boolean done = false; public void run() { try { - Thread.sleep(MEDIUM_DELAY_MS); + delay(MEDIUM_DELAY_MS); done = true; } catch (InterruptedException ok) {} } @@ -730,7 +1062,7 @@ public class JSR166TestCase extends Test public volatile boolean done = false; public void run() { try { - Thread.sleep(LONG_DELAY_MS); + delay(LONG_DELAY_MS); done = true; } catch (InterruptedException ok) {} } @@ -747,13 +1079,43 @@ public class JSR166TestCase extends Test public volatile boolean done = false; public Object call() { try { - Thread.sleep(SMALL_DELAY_MS); + delay(SMALL_DELAY_MS); done = true; } catch (InterruptedException ok) {} return Boolean.TRUE; } } + /** + * Analog of CheckedRunnable for RecursiveAction + */ + public abstract class CheckedRecursiveAction extends RecursiveAction { + protected abstract void realCompute() throws Throwable; + + public final void compute() { + try { + realCompute(); + } catch (Throwable t) { + threadUnexpectedException(t); + } + } + } + + /** + * Analog of CheckedCallable for RecursiveTask + */ + public abstract class CheckedRecursiveTask extends RecursiveTask { + protected abstract T realCompute() throws Throwable; + + public final T compute() { + try { + return realCompute(); + } catch (Throwable t) { + threadUnexpectedException(t); + return null; + } + } + } /** * For use as RejectedExecutionHandler in constructors @@ -763,4 +1125,67 @@ public class JSR166TestCase extends Test ThreadPoolExecutor executor) {} } + /** + * A CyclicBarrier that fails with AssertionFailedErrors instead + * of throwing checked exceptions. + */ + public class CheckedBarrier extends CyclicBarrier { + public CheckedBarrier(int parties) { super(parties); } + + public int await() { + try { + return super.await(); + } catch (Exception e) { + AssertionFailedError afe = + new AssertionFailedError("Unexpected exception: " + e); + afe.initCause(e); + throw afe; + } + } + } + + void checkEmpty(BlockingQueue q) { + try { + assertTrue(q.isEmpty()); + assertEquals(0, q.size()); + assertNull(q.peek()); + assertNull(q.poll()); + assertNull(q.poll(0, MILLISECONDS)); + assertEquals(q.toString(), "[]"); + assertTrue(Arrays.equals(q.toArray(), new Object[0])); + assertFalse(q.iterator().hasNext()); + try { + q.element(); + shouldThrow(); + } catch (NoSuchElementException success) {} + try { + q.iterator().next(); + shouldThrow(); + } catch (NoSuchElementException success) {} + try { + q.remove(); + shouldThrow(); + } catch (NoSuchElementException success) {} + } catch (InterruptedException ie) { + threadUnexpectedException(ie); + } + } + + @SuppressWarnings("unchecked") + T serialClone(T o) { + try { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(bos); + oos.writeObject(o); + oos.flush(); + oos.close(); + ByteArrayInputStream bin = + new ByteArrayInputStream(bos.toByteArray()); + ObjectInputStream ois = new ObjectInputStream(bin); + return (T) ois.readObject(); + } catch (Throwable t) { + threadUnexpectedException(t); + return null; + } + } }