--- jsr166/src/test/tck/JSR166TestCase.java 2004/01/07 01:02:17 1.16 +++ jsr166/src/test/tck/JSR166TestCase.java 2009/11/20 00:58:01 1.40 @@ -2,13 +2,14 @@ * 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. + * 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.*; @@ -17,20 +18,20 @@ import java.security.*; * 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 doe not otherwise arrange). The rules for creating such + * 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. @@ -44,7 +45,7 @@ import java.security.*; * is always discriminable as larger than SHORT and smaller than * MEDIUM. And so on. These constants are set to conservative values, * but even so, if there is ever any doubt, they can all be increased - * in one spot to rerun tests on slower platforms + * in one spot to rerun tests on slower platforms. * *
  4. All threads generated must be joined inside each test case * method (or fail to do so) before returning from the @@ -63,7 +64,7 @@ import java.security.*; * "normal" behaviors differ significantly. And sometimes testcases * cover multiple methods when they cannot be tested in * isolation.
    5. - * + * *
  5. The documentation style for testcases is to provide as javadoc * a simple sentence or two describing the property that the testcase * method purports to test. The javadocs do not say anything about how @@ -88,48 +89,68 @@ import java.security.*; 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) + if (args.length > 0) iters = Integer.parseInt(args[0]); Test s = suite(); - for (int i = 0; i < iters; ++i) + 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(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(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)); @@ -138,14 +159,20 @@ public class JSR166TestCase extends Test 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; } @@ -157,16 +184,16 @@ public class JSR166TestCase extends Test /** - * Return the shortest timed delay. This could + * Returns the shortest timed delay. This could * be reimplemented to use for example a Property. - */ + */ protected long getShortDelay() { - return 100; + return 50; } /** - * Set delays as multiples of SHORT_DELAY. + * Sets delays as multiples of SHORT_DELAY. */ protected void setDelays() { SHORT_DELAY_MS = getShortDelay(); @@ -181,23 +208,23 @@ public class JSR166TestCase extends Test volatile boolean threadFailed; /** - * Initialize test to indicate that no thread assertions have failed + * Initializes test to indicate that no thread assertions have failed */ - public void setUp() { + public void setUp() { setDelays(); - threadFailed = false; + 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); @@ -206,7 +233,7 @@ public class JSR166TestCase extends Test /** * If expression not true, set status to indicate current testcase * should fail - */ + */ public void threadAssertTrue(boolean b) { if (!b) { threadFailed = true; @@ -217,7 +244,7 @@ public class JSR166TestCase extends Test /** * If expression not false, set status to indicate current testcase * should fail - */ + */ public void threadAssertFalse(boolean b) { if (b) { threadFailed = true; @@ -228,7 +255,7 @@ public class JSR166TestCase extends Test /** * If argument not null, set status to indicate current testcase * should fail - */ + */ public void threadAssertNull(Object x) { if (x != null) { threadFailed = true; @@ -239,7 +266,7 @@ public class JSR166TestCase extends Test /** * If arguments not equal, set status to indicate current testcase * should fail - */ + */ public void threadAssertEquals(long x, long y) { if (x != y) { threadFailed = true; @@ -250,7 +277,7 @@ public class JSR166TestCase extends Test /** * 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; @@ -260,13 +287,21 @@ 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() { @@ -274,6 +309,14 @@ public class JSR166TestCase extends Test 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 @@ -281,8 +324,10 @@ public class JSR166TestCase extends Test public void joinPool(ExecutorService exec) { try { exec.shutdown(); - assertTrue(exec.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); - } catch(InterruptedException ie) { + assertTrue(exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + } catch (SecurityException ok) { + // Allowed in case test doesn't have privs + } catch (InterruptedException ie) { fail("Unexpected exception"); } } @@ -290,18 +335,33 @@ public class JSR166TestCase extends Test /** * 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); + } + /** * The number of elements to place in collections, arrays, etc. @@ -325,6 +385,7 @@ public class JSR166TestCase extends Test static final Integer m3 = new Integer(-3); static final Integer m4 = new Integer(-4); static final Integer m5 = new Integer(-5); + static final Integer m6 = new Integer(-6); static final Integer m10 = new Integer(-10); @@ -349,9 +410,125 @@ public class JSR166TestCase extends Test public void refresh() {} } + /** + * Sleep until the timeout has elapsed, or interrupted. + * Does NOT throw InterruptedException. + */ + void sleepTillInterrupted(long timeoutMillis) { + try { + Thread.sleep(timeoutMillis); + } catch (InterruptedException wakeup) { + } + } + + /** + * Returns a new started Thread running the given runnable. + */ + Thread newStartedThread(Runnable runnable) { + Thread t = new Thread(runnable); + t.start(); + return t; + } // Some convenient Runnable classes + abstract class CheckedRunnable implements Runnable { + abstract void realRun() throws Throwable; + + public final void run() { + try { + realRun(); + } catch (Throwable t) { + threadUnexpectedException(t); + } + } + } + + abstract class RunnableShouldThrow implements Runnable { + abstract void realRun() throws Throwable; + + final Class exceptionClass; + + RunnableShouldThrow(Class exceptionClass) { + this.exceptionClass = exceptionClass; + } + + public final void run() { + try { + realRun(); + threadShouldThrow(exceptionClass.getSimpleName()); + } catch (InterruptedException success) { + } catch (Throwable t) { + if (! exceptionClass.isInstance(t)) + threadUnexpectedException(t); + } + } + } + + abstract class ThreadShouldThrow extends Thread { + abstract void realRun() throws Throwable; + + final Class exceptionClass; + + ThreadShouldThrow(Class exceptionClass) { + this.exceptionClass = exceptionClass; + } + + public final void run() { + try { + realRun(); + threadShouldThrow(exceptionClass.getSimpleName()); + } catch (InterruptedException success) { + } catch (Throwable t) { + if (! exceptionClass.isInstance(t)) + threadUnexpectedException(t); + } + } + } + + abstract class CheckedInterruptedRunnable implements Runnable { + abstract void realRun() throws Throwable; + + public final void run() { + try { + realRun(); + threadShouldThrow("InterruptedException"); + } catch (InterruptedException success) { + } catch (Throwable t) { + threadUnexpectedException(t); + } + } + } + + abstract class CheckedCallable implements Callable { + abstract T realCall() throws Throwable; + + public final T call() { + try { + return realCall(); + } catch (Throwable t) { + threadUnexpectedException(t); + } + return null; + } + } + + abstract class CheckedInterruptedCallable implements Callable { + 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; + } + } + static class NoOpRunnable implements Runnable { public void run() {} } @@ -374,111 +551,75 @@ public class JSR166TestCase extends Test public Integer call() { return one; } } - class ShortRunnable implements Runnable { - public void run() { - try { - Thread.sleep(SHORT_DELAY_MS); - } - catch(Exception e) { - threadUnexpectedException(); - } + class ShortRunnable extends CheckedRunnable { + void realRun() throws Throwable { + Thread.sleep(SHORT_DELAY_MS); } } - class ShortInterruptedRunnable implements Runnable { - public void run() { - try { - Thread.sleep(SHORT_DELAY_MS); - threadShouldThrow(); - } - catch(InterruptedException success) { - } + class ShortInterruptedRunnable extends CheckedInterruptedRunnable { + void realRun() throws InterruptedException { + Thread.sleep(SHORT_DELAY_MS); } } - class SmallRunnable implements Runnable { - public void run() { - try { - Thread.sleep(SMALL_DELAY_MS); - } - catch(Exception e) { - threadUnexpectedException(); - } + class SmallRunnable extends CheckedRunnable { + void realRun() throws Throwable { + Thread.sleep(SMALL_DELAY_MS); } } - class SmallPossiblyInterruptedRunnable implements Runnable { - public void run() { + class SmallPossiblyInterruptedRunnable extends CheckedRunnable { + void realRun() { try { Thread.sleep(SMALL_DELAY_MS); } - catch(Exception e) { + catch (InterruptedException ok) { } } } - class SmallCallable implements Callable { - public Object call() { - try { - Thread.sleep(SMALL_DELAY_MS); - } - catch(Exception e) { - threadUnexpectedException(); - } + class SmallCallable extends CheckedCallable { + Object realCall() throws Throwable { + Thread.sleep(SMALL_DELAY_MS); return Boolean.TRUE; } } - class SmallInterruptedRunnable implements Runnable { - public void run() { - try { - Thread.sleep(SMALL_DELAY_MS); - threadShouldThrow(); - } - catch(InterruptedException success) { - } + class SmallInterruptedRunnable extends CheckedInterruptedRunnable { + void realRun() throws InterruptedException { + Thread.sleep(SMALL_DELAY_MS); } } - - class MediumRunnable implements Runnable { - public void run() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - } - catch(Exception e) { - threadUnexpectedException(); - } + class MediumRunnable extends CheckedRunnable { + void realRun() throws Throwable { + Thread.sleep(MEDIUM_DELAY_MS); } } - class MediumInterruptedRunnable implements Runnable { - public void run() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - threadShouldThrow(); - } - catch(InterruptedException success) { - } + class MediumInterruptedRunnable extends CheckedInterruptedRunnable { + void realRun() throws InterruptedException { + Thread.sleep(MEDIUM_DELAY_MS); } } - class MediumPossiblyInterruptedRunnable implements Runnable { - public void run() { + class MediumPossiblyInterruptedRunnable extends CheckedRunnable { + void realRun() { try { Thread.sleep(MEDIUM_DELAY_MS); } - catch(InterruptedException success) { + catch (InterruptedException ok) { } } } - class LongPossiblyInterruptedRunnable implements Runnable { - public void run() { + class LongPossiblyInterruptedRunnable extends CheckedRunnable { + void realRun() { try { Thread.sleep(LONG_DELAY_MS); } - catch(InterruptedException success) { + catch (InterruptedException ok) { } } } @@ -486,10 +627,10 @@ public class JSR166TestCase extends Test /** * For use as ThreadFactory in constructors */ - static class SimpleThreadFactory implements ThreadFactory{ - public Thread newThread(Runnable r){ + static class SimpleThreadFactory implements ThreadFactory { + public Thread newThread(Runnable r) { return new Thread(r); - } + } } static class TrackedShortRunnable implements Runnable { @@ -498,7 +639,7 @@ public class JSR166TestCase extends Test try { Thread.sleep(SMALL_DELAY_MS); done = true; - } catch(Exception e){ + } catch (InterruptedException ok) { } } } @@ -509,7 +650,7 @@ public class JSR166TestCase extends Test try { Thread.sleep(MEDIUM_DELAY_MS); done = true; - } catch(Exception e){ + } catch (InterruptedException ok) { } } } @@ -520,7 +661,7 @@ public class JSR166TestCase extends Test try { Thread.sleep(LONG_DELAY_MS); done = true; - } catch(Exception e){ + } catch (InterruptedException ok) { } } } @@ -538,7 +679,7 @@ public class JSR166TestCase extends Test try { Thread.sleep(SMALL_DELAY_MS); done = true; - } catch(Exception e){ + } catch (InterruptedException ok) { } return Boolean.TRUE; } @@ -548,9 +689,9 @@ public class JSR166TestCase extends Test /** * For use as RejectedExecutionHandler in constructors */ - static class NoOpREHandler implements RejectedExecutionHandler{ - public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){} + static class NoOpREHandler implements RejectedExecutionHandler { + public void rejectedExecution(Runnable r, + ThreadPoolExecutor executor) {} } - - + }