--- jsr166/src/test/tck/JSR166TestCase.java 2003/09/14 20:42:40 1.1 +++ jsr166/src/test/tck/JSR166TestCase.java 2009/12/01 05:41:40 1.46 @@ -1,107 +1,283 @@ /* - * Written by members of JCP JSR-166 Expert Group and released to the - * public domain. Use, modify, and redistribute this code in any way - * without acknowledgement. Other contributors include Andrew Wright, - * Jeffrey Hayes, Pat Fischer, Mike Judd. + * 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 + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ import junit.framework.*; import java.util.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.io.*; - +import java.security.*; /** - * Base class for JSR166 Junit TCK tests. Defines some constants and - * utility methods, as well as a simple framework for helping to make - * sure that assertions failing in generated threads cause the - * associated test that generated them to itself fail (which JUnit doe - * not otherwise arrange). The rules for creating such tests are: + * Base class for JSR166 Junit TCK tests. Defines some constants, + * utility methods and classes, as well as a simple framework for + * helping to make sure that assertions failing in generated threads + * cause the associated test that generated them to itself fail (which + * JUnit does not otherwise arrange). The rules for creating such + * tests are: * *
    * *
  1. All assertions in code running in generated threads must use - * the forms {@link threadFail} , {@link threadAssertTrue} {@link - * threadAssertEquals}, or {@link threadAssertNull}, (not + * the forms {@link #threadFail}, {@link #threadAssertTrue}, {@link + * #threadAssertEquals}, or {@link #threadAssertNull}, (not * fail, assertTrue, etc.) It is OK (but not * particularly recommended) for other code to use these forms too. * Only the most typically used JUnit assertion methods are defined * this way, but enough to live with.
    2. * - *
  2. If you override {@link setUp} or {@link tearDown}, make sure + *
  3. If you override {@link #setUp} or {@link #tearDown}, make sure * to invoke super.setUp and super.tearDown within * them. These methods are used to clear and check for thread * assertion failures.
    4. * - *
  4. All delays and timeouts must use one of the constants {@link - * SHORT_DELAY_MS}, {@link SMALL_DELAY_MS}, {@link MEDIUM_DELAY_MS}, - * {@link LONG_DELAY_MS}. The idea here is that a SHORT is always - * discriminatable from zero time, and always allows enough time for - * the small amounts of computation (creating a thread, calling a few + *
  5. All delays and timeouts must use one of the constants + * SHORT_DELAY_MS, SMALL_DELAY_MS, MEDIUM_DELAY_MS, + * LONG_DELAY_MS. The idea here is that a SHORT is always + * discriminable from zero time, and always allows enough time for the + * small amounts of computation (creating a thread, calling a few * methods, etc) needed to reach a timeout point. Similarly, a SMALL * is always discriminable as larger than SHORT and smaller than * MEDIUM. And so on. These constants are set to conservative values, - * (100, 500, 1000, 5000 MS) but even so, if there is ever any doubt, - * they can all be increased in one spot to rerun tests on slower - * platforms
    6. + * but even so, if there is ever any doubt, they can all be increased + * in one spot to rerun tests on slower platforms. * *
  6. All threads generated must be joined inside each test case * method (or fail to do so) before returning from the - * method. The {@link joinPool} method can be used to do this when + * method. The joinPool method can be used to do this when * using Executors.
    7. * *
+ * + *

Other notes + *

*/ public class JSR166TestCase extends TestCase { + /** + * Runs all JSR166 unit tests using junit.textui.TestRunner + */ + public static void main(String[] args) { + int iters = 1; + if (args.length > 0) + iters = Integer.parseInt(args[0]); + Test s = suite(); + for (int i = 0; i < iters; ++i) { + junit.textui.TestRunner.run(s); + System.gc(); + System.runFinalization(); + } + System.exit(0); + } + + /** + * 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(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; + } + + + public static long SHORT_DELAY_MS; + public static long SMALL_DELAY_MS; + public static long MEDIUM_DELAY_MS; + public static long LONG_DELAY_MS; + + + /** + * Returns the shortest timed delay. This could + * be reimplemented to use for example a Property. + */ + protected long getShortDelay() { + return 50; + } + + + /** + * Sets delays as multiples of SHORT_DELAY. + */ + protected void setDelays() { + SHORT_DELAY_MS = getShortDelay(); + SMALL_DELAY_MS = SHORT_DELAY_MS * 5; + MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10; + LONG_DELAY_MS = SHORT_DELAY_MS * 50; + } /** * Flag set true if any threadAssert methods fail */ - protected volatile boolean threadFailed; + volatile boolean threadFailed; /** - * Initialize test to indicat that no thread assertions have failed + * Initializes test to indicate that no thread assertions have failed */ - public void setUp() { - threadFailed = false; + public void setUp() { + setDelays(); + threadFailed = false; } /** - * Trigger test case failure if any thread assertions have failed + * Triggers test case failure if any thread assertions have failed */ - public void tearDown() { - assertFalse(threadFailed); + public void tearDown() { + assertFalse(threadFailed); } + /** + * Fail, also setting status to indicate current testcase should fail + */ public void threadFail(String reason) { threadFailed = true; fail(reason); } + /** + * If expression not true, set status to indicate current testcase + * should fail + */ public void threadAssertTrue(boolean b) { if (!b) { threadFailed = true; assertTrue(b); } } + + /** + * If expression not false, set status to indicate current testcase + * should fail + */ public void threadAssertFalse(boolean b) { if (b) { threadFailed = true; assertFalse(b); } } + + /** + * If argument not null, set status to indicate current testcase + * should fail + */ public void threadAssertNull(Object x) { if (x != null) { threadFailed = true; assertNull(x); } } + + /** + * If arguments not equal, set status to indicate current testcase + * should fail + */ public void threadAssertEquals(long x, long y) { if (x != y) { threadFailed = true; assertEquals(x, y); } } + + /** + * If arguments not equal, set status to indicate current testcase + * should fail + */ public void threadAssertEquals(Object x, Object y) { if (x != y && (x == null || !x.equals(y))) { threadFailed = true; @@ -110,21 +286,81 @@ public class JSR166TestCase extends Test } /** + * threadFail with message "should throw exception" + */ + public void threadShouldThrow() { + threadFailed = true; + fail("should throw exception"); + } + + /** + * threadFail with message "should throw" + exceptionName + */ + public void threadShouldThrow(String exceptionName) { + threadFailed = true; + fail("should throw " + exceptionName); + } + + /** + * threadFail with message "Unexpected exception" + */ + public void threadUnexpectedException() { + threadFailed = true; + fail("Unexpected exception"); + } + + /** + * threadFail with message "Unexpected exception", with argument + */ + public void threadUnexpectedException(Throwable ex) { + threadFailed = true; + ex.printStackTrace(); + fail("Unexpected exception: " + ex); + } + + /** * Wait out termination of a thread pool or fail doing so */ public void joinPool(ExecutorService exec) { try { exec.shutdown(); - assertTrue(exec.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch(InterruptedException ie) { - fail("unexpected exception"); + assertTrue(exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + } catch (SecurityException ok) { + // Allowed in case test doesn't have privs + } catch (InterruptedException ie) { + fail("Unexpected InterruptedException"); } } - public static final long SHORT_DELAY_MS = 100; - public static final long SMALL_DELAY_MS = 500; - public static final long MEDIUM_DELAY_MS = 1000; - public static final long LONG_DELAY_MS = 5000; + + /** + * fail with message "should throw exception" + */ + public void shouldThrow() { + fail("Should throw exception"); + } + + /** + * fail with message "should throw " + exceptionName + */ + public void shouldThrow(String exceptionName) { + fail("Should throw " + exceptionName); + } + + /** + * fail with message "Unexpected exception" + */ + public void unexpectedException() { + fail("Unexpected exception"); + } + + /** + * fail with message "Unexpected exception", with argument + */ + public void unexpectedException(Throwable ex) { + ex.printStackTrace(); + fail("Unexpected exception: " + ex); + } /** @@ -149,106 +385,300 @@ public class JSR166TestCase extends Test public static final Integer m3 = new Integer(-3); public static final Integer m4 = new Integer(-4); public static final Integer m5 = new Integer(-5); + public static final Integer m6 = new Integer(-6); public static final Integer m10 = new Integer(-10); - // Some convenient Runnable classes + /** + * A security policy where new permissions can be dynamically added + * or all cleared. + */ + public static class AdjustablePolicy extends java.security.Policy { + Permissions perms = new Permissions(); + AdjustablePolicy() { } + void addPermission(Permission perm) { perms.add(perm); } + void clearPermissions() { perms = new Permissions(); } + public PermissionCollection getPermissions(CodeSource cs) { + return perms; + } + public PermissionCollection getPermissions(ProtectionDomain pd) { + return perms; + } + public boolean implies(ProtectionDomain pd, Permission p) { + return perms.implies(p); + } + public void refresh() {} + } - public static class NoOpRunnable implements Runnable { - public void run() {} + /** + * Sleep until the timeout has elapsed, or interrupted. + * Does NOT throw InterruptedException. + */ + void sleepTillInterrupted(long timeoutMillis) { + try { + Thread.sleep(timeoutMillis); + } catch (InterruptedException wakeup) {} } - public static class NoOpCallable implements Callable { - public Object call() { return Boolean.TRUE; } + /** + * Returns a new started Thread running the given runnable. + */ + Thread newStartedThread(Runnable runnable) { + Thread t = new Thread(runnable); + t.start(); + return t; } - public class ShortRunnable implements Runnable { - public void run() { + // Some convenient Runnable classes + + public abstract class CheckedRunnable implements Runnable { + protected abstract void realRun() throws Throwable; + + public final void run() { try { - Thread.sleep(SHORT_DELAY_MS); + realRun(); + } catch (Throwable t) { + threadUnexpectedException(t); } - catch(Exception e) { - threadFail("unexpectedException"); + } + } + + public abstract class RunnableShouldThrow implements Runnable { + protected abstract void realRun() throws Throwable; + + final Class exceptionClass; + + RunnableShouldThrow(Class exceptionClass) { + this.exceptionClass = exceptionClass; + } + + public final void run() { + try { + realRun(); + threadShouldThrow(exceptionClass.getSimpleName()); + } catch (Throwable t) { + if (! exceptionClass.isInstance(t)) + threadUnexpectedException(t); } } } - public class ShortInterruptedRunnable implements Runnable { - public void run() { + public abstract class ThreadShouldThrow extends Thread { + protected abstract void realRun() throws Throwable; + + final Class exceptionClass; + + ThreadShouldThrow(Class exceptionClass) { + this.exceptionClass = exceptionClass; + } + + public final void run() { try { - Thread.sleep(SHORT_DELAY_MS); - threadFail("should throw IE"); + realRun(); + threadShouldThrow(exceptionClass.getSimpleName()); + } catch (Throwable t) { + if (! exceptionClass.isInstance(t)) + threadUnexpectedException(t); } - catch(InterruptedException success) { + } + } + + public abstract class CheckedInterruptedRunnable implements Runnable { + protected abstract void realRun() throws Throwable; + + public final void run() { + try { + realRun(); + threadShouldThrow("InterruptedException"); + } catch (InterruptedException success) { + } catch (Throwable t) { + threadUnexpectedException(t); } } } - public class SmallRunnable implements Runnable { - public void run() { + public abstract class CheckedCallable implements Callable { + protected abstract T realCall() throws Throwable; + + public final T call() { try { - Thread.sleep(SMALL_DELAY_MS); + return realCall(); + } catch (Throwable t) { + threadUnexpectedException(t); } - catch(Exception e) { - threadFail("unexpectedException"); + return null; + } + } + + public abstract class CheckedInterruptedCallable implements Callable { + protected abstract T realCall() throws Throwable; + + public final T call() { + try { + T result = realCall(); + threadShouldThrow("InterruptedException"); + return result; + } catch (InterruptedException success) { + } catch (Throwable t) { + threadUnexpectedException(t); } + return null; } } - public class SmallCallable implements Callable { - public Object call() { + public static class NoOpRunnable implements Runnable { + public void run() {} + } + + public static class NoOpCallable implements Callable { + public Object call() { return Boolean.TRUE; } + } + + public static final String TEST_STRING = "a test string"; + + public static class StringTask implements Callable { + public String call() { return TEST_STRING; } + } + + public static class NPETask implements Callable { + public String call() { throw new NullPointerException(); } + } + + public static class CallableOne implements Callable { + public Integer call() { return one; } + } + + public class ShortRunnable extends CheckedRunnable { + protected void realRun() throws Throwable { + Thread.sleep(SHORT_DELAY_MS); + } + } + + public class ShortInterruptedRunnable extends CheckedInterruptedRunnable { + protected void realRun() throws InterruptedException { + Thread.sleep(SHORT_DELAY_MS); + } + } + + public class SmallRunnable extends CheckedRunnable { + protected void realRun() throws Throwable { + Thread.sleep(SMALL_DELAY_MS); + } + } + + public class SmallPossiblyInterruptedRunnable extends CheckedRunnable { + protected void realRun() { try { Thread.sleep(SMALL_DELAY_MS); - } - catch(Exception e) { - threadFail("unexpectedException"); - } + } catch (InterruptedException ok) {} + } + } + + public class SmallCallable extends CheckedCallable { + protected Object realCall() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); return Boolean.TRUE; } } - public class SmallInterruptedRunnable implements Runnable { + 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); + } + } + + public class MediumInterruptedRunnable extends CheckedInterruptedRunnable { + protected void realRun() throws InterruptedException { + Thread.sleep(MEDIUM_DELAY_MS); + } + } + + public class MediumPossiblyInterruptedRunnable extends CheckedRunnable { + protected void realRun() { + try { + Thread.sleep(MEDIUM_DELAY_MS); + } catch (InterruptedException ok) {} + } + } + + public class LongPossiblyInterruptedRunnable extends CheckedRunnable { + protected void realRun() { + try { + Thread.sleep(LONG_DELAY_MS); + } catch (InterruptedException ok) {} + } + } + + /** + * For use as ThreadFactory in constructors + */ + public static class SimpleThreadFactory implements ThreadFactory { + public Thread newThread(Runnable r) { + return new Thread(r); + } + } + + public static class TrackedShortRunnable implements Runnable { + public volatile boolean done = false; public void run() { try { Thread.sleep(SMALL_DELAY_MS); - threadFail("should throw IE"); - } - catch(InterruptedException success) { - } + done = true; + } catch (InterruptedException ok) {} } } - - public class MediumRunnable implements Runnable { + public static class TrackedMediumRunnable implements Runnable { + public volatile boolean done = false; public void run() { try { Thread.sleep(MEDIUM_DELAY_MS); - } - catch(Exception e) { - threadFail("unexpectedException"); - } + done = true; + } catch (InterruptedException ok) {} } } - public class MediumInterruptedRunnable implements Runnable { + public static class TrackedLongRunnable implements Runnable { + public volatile boolean done = false; public void run() { try { - Thread.sleep(MEDIUM_DELAY_MS); - threadFail("should throw IE"); - } - catch(InterruptedException success) { - } + Thread.sleep(LONG_DELAY_MS); + done = true; + } catch (InterruptedException ok) {} } } - public class MediumPossiblyInterruptedRunnable implements Runnable { + public static class TrackedNoOpRunnable implements Runnable { + public volatile boolean done = false; public void run() { + done = true; + } + } + + public static class TrackedCallable implements Callable { + public volatile boolean done = false; + public Object call() { try { - Thread.sleep(MEDIUM_DELAY_MS); - } - catch(InterruptedException success) { - } + Thread.sleep(SMALL_DELAY_MS); + done = true; + } catch (InterruptedException ok) {} + return Boolean.TRUE; } } - + + + /** + * For use as RejectedExecutionHandler in constructors + */ + public static class NoOpREHandler implements RejectedExecutionHandler { + public void rejectedExecution(Runnable r, + ThreadPoolExecutor executor) {} + } + }