--- jsr166/src/test/tck/JSR166TestCase.java 2009/08/05 00:43:59 1.38 +++ jsr166/src/test/tck/JSR166TestCase.java 2009/11/26 15:42:15 1.45 @@ -90,13 +90,13 @@ public class JSR166TestCase extends Test /** * Runs all JSR166 unit tests using junit.textui.TestRunner */ - public static void main (String[] args) { + 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); + junit.textui.TestRunner.run(s); System.gc(); System.runFinalization(); } @@ -106,7 +106,7 @@ public class JSR166TestCase extends Test /** * Collects all JSR166 unit tests as one suite */ - public static Test suite ( ) { + public static Test suite() { TestSuite suite = new TestSuite("JSR166 Unit Tests"); suite.addTest(new TestSuite(ForkJoinPoolTest.class)); @@ -195,7 +195,7 @@ public class JSR166TestCase extends Test /** * Sets delays as multiples of SHORT_DELAY. */ - protected void setDelays() { + protected void setDelays() { SHORT_DELAY_MS = getShortDelay(); SMALL_DELAY_MS = SHORT_DELAY_MS * 5; MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10; @@ -294,6 +294,14 @@ public class JSR166TestCase extends Test } /** + * 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() { @@ -320,7 +328,7 @@ public class JSR166TestCase extends Test } catch (SecurityException ok) { // Allowed in case test doesn't have privs } catch (InterruptedException ie) { - fail("Unexpected exception"); + fail("Unexpected InterruptedException"); } } @@ -333,6 +341,13 @@ public class JSR166TestCase extends Test } /** + * fail with message "should throw " + exceptionName + */ + public void shouldThrow(String exceptionName) { + fail("Should throw " + exceptionName); + } + + /** * fail with message "Unexpected exception" */ public void unexpectedException() { @@ -351,48 +366,48 @@ public class JSR166TestCase extends Test /** * The number of elements to place in collections, arrays, etc. */ - static final int SIZE = 20; + public static final int SIZE = 20; // Some convenient Integer constants - 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 m6 = new Integer(-6); - static final Integer m10 = new Integer(-10); + 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 m6 = new Integer(-6); + public 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 { + 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 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() {} } /** @@ -402,8 +417,7 @@ public class JSR166TestCase extends Test void sleepTillInterrupted(long timeoutMillis) { try { Thread.sleep(timeoutMillis); - } catch (InterruptedException wakeup) { - } + } catch (InterruptedException wakeup) {} } /** @@ -417,8 +431,8 @@ public class JSR166TestCase extends Test // Some convenient Runnable classes - abstract class CheckedRunnable implements Runnable { - abstract void realRun() throws Throwable; + public abstract class CheckedRunnable implements Runnable { + protected abstract void realRun() throws Throwable; public final void run() { try { @@ -429,13 +443,55 @@ public class JSR166TestCase extends Test } } - abstract class CheckedInterruptedRunnable implements Runnable { - abstract void realRun() throws Throwable; + 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 (InterruptedException success) { + } catch (Throwable t) { + if (! exceptionClass.isInstance(t)) + threadUnexpectedException(t); + } + } + } + + 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 { realRun(); - threadShouldThrow(); + threadShouldThrow(exceptionClass.getSimpleName()); + } catch (InterruptedException success) { + } catch (Throwable t) { + if (! exceptionClass.isInstance(t)) + threadUnexpectedException(t); + } + } + } + + 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); @@ -443,171 +499,177 @@ public class JSR166TestCase extends Test } } - abstract class CheckedCallable implements Callable { - abstract T realCall() throws Throwable; + public abstract class CheckedCallable implements Callable { + protected abstract T realCall() throws Throwable; public final T call() { try { return realCall(); } catch (Throwable t) { threadUnexpectedException(t); - return null; } + return null; } } - static class NoOpRunnable implements Runnable { + 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 static class NoOpRunnable implements Runnable { public void run() {} } - static class NoOpCallable implements Callable { + public static class NoOpCallable implements Callable { public Object call() { return Boolean.TRUE; } } - static final String TEST_STRING = "a test string"; + public static final String TEST_STRING = "a test string"; - static class StringTask implements Callable { + public static class StringTask implements Callable { public String call() { return TEST_STRING; } } - static class NPETask implements Callable { + public static class NPETask implements Callable { public String call() { throw new NullPointerException(); } } - static class CallableOne implements Callable { + public static class CallableOne implements Callable { public Integer call() { return one; } } - class ShortRunnable extends CheckedRunnable { - void realRun() throws Throwable { + public class ShortRunnable extends CheckedRunnable { + protected void realRun() throws Throwable { Thread.sleep(SHORT_DELAY_MS); } } - class ShortInterruptedRunnable extends CheckedInterruptedRunnable { - void realRun() throws InterruptedException { + public class ShortInterruptedRunnable extends CheckedInterruptedRunnable { + protected void realRun() throws InterruptedException { Thread.sleep(SHORT_DELAY_MS); } } - class SmallRunnable extends CheckedRunnable { - void realRun() throws Throwable { + public class SmallRunnable extends CheckedRunnable { + protected void realRun() throws Throwable { Thread.sleep(SMALL_DELAY_MS); } } - class SmallPossiblyInterruptedRunnable extends CheckedRunnable { - void realRun() { + public class SmallPossiblyInterruptedRunnable extends CheckedRunnable { + protected void realRun() { try { Thread.sleep(SMALL_DELAY_MS); - } - catch (InterruptedException ok) { - } + } catch (InterruptedException ok) {} } } - class SmallCallable extends CheckedCallable { - Object realCall() throws Throwable { + public class SmallCallable extends CheckedCallable { + protected Object realCall() throws InterruptedException { Thread.sleep(SMALL_DELAY_MS); return Boolean.TRUE; } } - class SmallInterruptedRunnable extends CheckedInterruptedRunnable { - void realRun() throws InterruptedException { + public class SmallInterruptedRunnable extends CheckedInterruptedRunnable { + protected void realRun() throws InterruptedException { Thread.sleep(SMALL_DELAY_MS); } } - class MediumRunnable extends CheckedRunnable { - void realRun() throws Throwable { + public class MediumRunnable extends CheckedRunnable { + protected void realRun() throws Throwable { Thread.sleep(MEDIUM_DELAY_MS); } } - class MediumInterruptedRunnable extends CheckedInterruptedRunnable { - void realRun() throws InterruptedException { + public class MediumInterruptedRunnable extends CheckedInterruptedRunnable { + protected void realRun() throws InterruptedException { Thread.sleep(MEDIUM_DELAY_MS); } } - class MediumPossiblyInterruptedRunnable extends CheckedRunnable { - void realRun() { + public class MediumPossiblyInterruptedRunnable extends CheckedRunnable { + protected void realRun() { try { Thread.sleep(MEDIUM_DELAY_MS); - } - catch (InterruptedException ok) { - } + } catch (InterruptedException ok) {} } } - class LongPossiblyInterruptedRunnable extends CheckedRunnable { - void realRun() { + public class LongPossiblyInterruptedRunnable extends CheckedRunnable { + protected void realRun() { try { Thread.sleep(LONG_DELAY_MS); - } - catch (InterruptedException ok) { - } + } catch (InterruptedException ok) {} } } /** * For use as ThreadFactory in constructors */ - static class SimpleThreadFactory implements ThreadFactory { + public static class SimpleThreadFactory implements ThreadFactory { public Thread newThread(Runnable r) { return new Thread(r); } } - static class TrackedShortRunnable implements Runnable { - volatile boolean done = false; + public static class TrackedShortRunnable implements Runnable { + public volatile boolean done = false; public void run() { try { Thread.sleep(SMALL_DELAY_MS); done = true; - } catch (Exception e) { - } + } catch (InterruptedException ok) {} } } - static class TrackedMediumRunnable implements Runnable { - volatile boolean done = false; + public static class TrackedMediumRunnable implements Runnable { + public volatile boolean done = false; public void run() { try { Thread.sleep(MEDIUM_DELAY_MS); done = true; - } catch (Exception e) { - } + } catch (InterruptedException ok) {} } } - static class TrackedLongRunnable implements Runnable { - volatile boolean done = false; + public static class TrackedLongRunnable implements Runnable { + public volatile boolean done = false; public void run() { try { Thread.sleep(LONG_DELAY_MS); done = true; - } catch (Exception e) { - } + } catch (InterruptedException ok) {} } } - static class TrackedNoOpRunnable implements Runnable { - volatile boolean done = false; + public static class TrackedNoOpRunnable implements Runnable { + public volatile boolean done = false; public void run() { done = true; } } - static class TrackedCallable implements Callable { - volatile boolean done = false; + public static class TrackedCallable implements Callable { + public volatile boolean done = false; public Object call() { try { Thread.sleep(SMALL_DELAY_MS); done = true; - } catch (Exception e) { - } + } catch (InterruptedException ok) {} return Boolean.TRUE; } } @@ -616,7 +678,7 @@ public class JSR166TestCase extends Test /** * For use as RejectedExecutionHandler in constructors */ - static class NoOpREHandler implements RejectedExecutionHandler { + public static class NoOpREHandler implements RejectedExecutionHandler { public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {} }