--- jsr166/src/test/tck/JSR166TestCase.java 2003/09/20 00:31:57 1.2 +++ jsr166/src/test/tck/JSR166TestCase.java 2003/12/25 19:48:57 1.12 @@ -9,14 +9,15 @@ import junit.framework.*; import java.util.*; import java.util.concurrent.*; 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 doe not otherwise arrange). The rules for creating such + * tests are: * *
    * @@ -33,11 +34,11 @@ import java.io.*; * them. These methods are used to clear and check for thread * assertion failures. * - *
  1. 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 + *
  2. 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, @@ -46,12 +47,101 @@ import java.io.*; * *
  3. 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.
    4. * *
+ * + *

Other notes + *

*/ public class JSR166TestCase extends TestCase { + /** + * Runs all JSR166 unit tests using junit.textui.TestRunner + */ + public static void main (String[] args) { + junit.textui.TestRunner.run (suite()); + } + + /** + * Collects all JSR166 unit tests as one suite + */ + public static Test suite ( ) { + TestSuite suite = new TestSuite("JSR166 Unit Tests"); + + suite.addTest(new TestSuite(AbstractExecutorServiceTest.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(ConcurrentHashMapTest.class)); + suite.addTest(new TestSuite(ConcurrentLinkedQueueTest.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(ExchangerTest.class)); + suite.addTest(new TestSuite(ExecutorsTest.class)); + suite.addTest(new TestSuite(ExecutorCompletionServiceTest.class)); + suite.addTest(new TestSuite(FutureTaskTest.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(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(ThreadTest.class)); + suite.addTest(new TestSuite(TimeUnitTest.class)); + + return suite; + } + public static long SHORT_DELAY_MS; public static long SMALL_DELAY_MS; @@ -64,12 +154,12 @@ public class JSR166TestCase extends Test * be reimplmented to use for example a Property. */ protected long getShortDelay() { - return 50; + return 100; } /** - * Set delays as multiples fo SHORT_DELAY. + * Set delays as multiples of SHORT_DELAY. */ protected void setDelays() { SHORT_DELAY_MS = getShortDelay(); @@ -81,10 +171,10 @@ public class JSR166TestCase extends Test /** * 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 + * Initialize test to indicate that no thread assertions have failed */ public void setUp() { setDelays(); @@ -98,35 +188,62 @@ public class JSR166TestCase extends Test 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; @@ -135,6 +252,23 @@ public class JSR166TestCase extends Test } /** + * threadFail with message "should throw exception" + */ + public void threadShouldThrow() { + threadFailed = true; + fail("should throw exception"); + } + + /** + * threadFail with message "Unexpected exception" + */ + public void threadUnexpectedException() { + threadFailed = true; + fail("Unexpected exception"); + } + + + /** * Wait out termination of a thread pool or fail doing so */ public void joinPool(ExecutorService exec) { @@ -142,97 +276,157 @@ public class JSR166TestCase extends Test exec.shutdown(); assertTrue(exec.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); } catch(InterruptedException ie) { - fail("unexpected exception"); + fail("Unexpected exception"); } } + /** + * fail with message "should throw exception" + */ + public void shouldThrow() { + fail("Should throw exception"); + } + + /** + * fail with message "Unexpected exception" + */ + public void unexpectedException() { + fail("Unexpected exception"); + } + /** * The number of elements to place in collections, arrays, etc. */ - public static final int SIZE = 20; + static final int SIZE = 20; // Some convenient Integer constants - public static final Integer zero = new Integer(0); - public static final Integer one = new Integer(1); - public static final Integer two = new Integer(2); - public static final Integer three = new Integer(3); - public static final Integer four = new Integer(4); - public static final Integer five = new Integer(5); - public static final Integer six = new Integer(6); - public static final Integer seven = new Integer(7); - public static final Integer eight = new Integer(8); - public static final Integer nine = new Integer(9); - public static final Integer m1 = new Integer(-1); - public static final Integer m2 = new Integer(-2); - 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 m10 = new Integer(-10); + static final Integer zero = new Integer(0); + static final Integer one = new Integer(1); + static final Integer two = new Integer(2); + static final Integer three = new Integer(3); + static final Integer four = new Integer(4); + static final Integer five = new Integer(5); + static final Integer six = new Integer(6); + static final Integer seven = new Integer(7); + static final Integer eight = new Integer(8); + static final Integer nine = new Integer(9); + static final Integer m1 = new Integer(-1); + static final Integer m2 = new Integer(-2); + static final Integer m3 = new Integer(-3); + static final Integer m4 = new Integer(-4); + static final Integer m5 = new Integer(-5); + static final Integer m10 = new Integer(-10); + + + /** + * A security policy where new permissions can be dynamically added + * or all cleared. + */ + 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() {} + } // Some convenient Runnable classes - public static class NoOpRunnable implements Runnable { + static class NoOpRunnable implements Runnable { public void run() {} } - public static class NoOpCallable implements Callable { + static class NoOpCallable implements Callable { public Object call() { return Boolean.TRUE; } } - public class ShortRunnable implements Runnable { + static final String TEST_STRING = "a test string"; + + static class StringTask implements Callable { + public String call() { return TEST_STRING; } + } + + static class NPETask implements Callable { + public String call() { throw new NullPointerException(); } + } + + static class CallableOne implements Callable { + public Integer call() { return one; } + } + + class ShortRunnable implements Runnable { public void run() { try { Thread.sleep(SHORT_DELAY_MS); } catch(Exception e) { - threadFail("unexpectedException"); + threadUnexpectedException(); } } } - public class ShortInterruptedRunnable implements Runnable { + class ShortInterruptedRunnable implements Runnable { public void run() { try { Thread.sleep(SHORT_DELAY_MS); - threadFail("should throw IE"); + threadShouldThrow(); } catch(InterruptedException success) { } } } - public class SmallRunnable implements Runnable { + class SmallRunnable implements Runnable { public void run() { try { Thread.sleep(SMALL_DELAY_MS); } catch(Exception e) { - threadFail("unexpectedException"); + threadUnexpectedException(); } } } - public class SmallCallable implements Callable { + class SmallPossiblyInterruptedRunnable implements Runnable { + public void run() { + try { + Thread.sleep(SMALL_DELAY_MS); + } + catch(Exception e) { + } + } + } + + class SmallCallable implements Callable { public Object call() { try { Thread.sleep(SMALL_DELAY_MS); } catch(Exception e) { - threadFail("unexpectedException"); + threadUnexpectedException(); } return Boolean.TRUE; } } - public class SmallInterruptedRunnable implements Runnable { + class SmallInterruptedRunnable implements Runnable { public void run() { try { Thread.sleep(SMALL_DELAY_MS); - threadFail("should throw IE"); + threadShouldThrow(); } catch(InterruptedException success) { } @@ -240,29 +434,29 @@ public class JSR166TestCase extends Test } - public class MediumRunnable implements Runnable { + class MediumRunnable implements Runnable { public void run() { try { Thread.sleep(MEDIUM_DELAY_MS); } catch(Exception e) { - threadFail("unexpectedException"); + threadUnexpectedException(); } } } - public class MediumInterruptedRunnable implements Runnable { + class MediumInterruptedRunnable implements Runnable { public void run() { try { Thread.sleep(MEDIUM_DELAY_MS); - threadFail("should throw IE"); + threadShouldThrow(); } catch(InterruptedException success) { } } } - public class MediumPossiblyInterruptedRunnable implements Runnable { + class MediumPossiblyInterruptedRunnable implements Runnable { public void run() { try { Thread.sleep(MEDIUM_DELAY_MS); @@ -271,5 +465,84 @@ public class JSR166TestCase extends Test } } } + + class LongPossiblyInterruptedRunnable implements Runnable { + public void run() { + try { + Thread.sleep(LONG_DELAY_MS); + } + catch(InterruptedException success) { + } + } + } + + /** + * For use as ThreadFactory in constructors + */ + static class SimpleThreadFactory implements ThreadFactory{ + public Thread newThread(Runnable r){ + return new Thread(r); + } + } + + static class TrackedShortRunnable implements Runnable { + volatile boolean done = false; + public void run() { + try { + Thread.sleep(SMALL_DELAY_MS); + done = true; + } catch(Exception e){ + } + } + } + + static class TrackedMediumRunnable implements Runnable { + volatile boolean done = false; + public void run() { + try { + Thread.sleep(MEDIUM_DELAY_MS); + done = true; + } catch(Exception e){ + } + } + } + + static class TrackedLongRunnable implements Runnable { + volatile boolean done = false; + public void run() { + try { + Thread.sleep(LONG_DELAY_MS); + done = true; + } catch(Exception e){ + } + } + } + + static class TrackedNoOpRunnable implements Runnable { + volatile boolean done = false; + public void run() { + done = true; + } + } + + static class TrackedCallable implements Callable { + volatile boolean done = false; + public Object call() { + try { + Thread.sleep(SMALL_DELAY_MS); + done = true; + } catch(Exception e){ + } + return Boolean.TRUE; + } + } + + /** + * For use as RejectedExecutionHandler in constructors + */ + static class NoOpREHandler implements RejectedExecutionHandler{ + public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){} + } + }