--- jsr166/src/test/tck/JSR166TestCase.java 2010/01/05 02:08:37 1.49 +++ jsr166/src/test/tck/JSR166TestCase.java 2010/09/17 00:52:36 1.54 @@ -7,11 +7,17 @@ */ import junit.framework.*; -import java.util.*; +import java.util.PropertyPermission; import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicReference; import static java.util.concurrent.TimeUnit.MILLISECONDS; -import java.io.*; -import java.security.*; +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, @@ -26,19 +32,19 @@ import java.security.*; *
  • All assertions in code running in generated threads must use * the forms {@link #threadFail}, {@link #threadAssertTrue}, {@link * #threadAssertEquals}, or {@link #threadAssertNull}, (not - * fail, assertTrue, etc.) It is OK (but not + * {@code fail}, {@code 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.
    • * *
  • If you override {@link #setUp} or {@link #tearDown}, make sure - * to invoke super.setUp and super.tearDown within + * to invoke {@code super.setUp} and {@code super.tearDown} within * them. These methods are used to clear and check for thread * assertion failures.
    • * - *
  • 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 + *
  • All delays and timeouts must use one of the constants {@code + * SHORT_DELAY_MS}, {@code SMALL_DELAY_MS}, {@code MEDIUM_DELAY_MS}, + * {@code 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 @@ -48,8 +54,8 @@ import java.security.*; * in one spot to rerun tests on slower platforms.
    • * *
  • All threads generated must be joined inside each test case - * method (or fail to do so) before returning from the - * method. The joinPool method can be used to do this when + * method (or {@code fail} to do so) before returning from the + * method. The {@code joinPool} method can be used to do this when * using Executors.
    • * * @@ -81,7 +87,7 @@ import java.security.*; * any particular package to simplify things for people integrating * them in TCK test suites. * - *
  • As a convenience, the main of this class (JSR166TestCase) + *
  • As a convenience, the {@code main} of this class (JSR166TestCase) * runs all JSR166 unit tests.
    • * * @@ -143,6 +149,7 @@ public class JSR166TestCase extends Test 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)); @@ -205,134 +212,188 @@ public class JSR166TestCase extends Test */ 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 * 50; } /** - * Flag set true if any threadAssert methods fail + * The first exception encountered if any threadAssertXXX method fails. */ - volatile boolean threadFailed; + private final AtomicReference threadFailure + = new AtomicReference(null); /** - * Initializes test to indicate that no thread assertions have failed + * 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); + * Triggers test case failure if any thread assertions have failed, + * by rethrowing, in the test harness thread, any exception recorded + * earlier by threadRecordFailure. + */ + public void tearDown() throws Exception { + Throwable t = threadFailure.get(); + 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 + throw new AssertionError(t); + } } /** - * Fail, also setting status to indicate current testcase should fail + * Just like fail(reason), but additionally recording (using + * threadRecordFailure) any AssertionError thrown, so that the current + * testcase will fail. */ public void threadFail(String reason) { - threadFailed = true; - fail(reason); + try { + fail(reason); + } catch (Throwable 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 AssertionError thrown, so that the current + * testcase will fail. */ public void threadAssertTrue(boolean b) { - if (!b) { - threadFailed = true; + try { assertTrue(b); + } catch (AssertionError 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 AssertionError thrown, so that the + * current testcase will fail. */ public void threadAssertFalse(boolean b) { - if (b) { - threadFailed = true; + try { assertFalse(b); + } catch (AssertionError 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 AssertionError thrown, so that the + * current testcase will fail. */ public void threadAssertNull(Object x) { - if (x != null) { - threadFailed = true; + try { assertNull(x); + } catch (AssertionError 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 AssertionError 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 (AssertionError 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 AssertionError 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 (AssertionError t) { + threadRecordFailure(t); + throw t; } } /** - * threadFail with message "should throw exception" + * Just like assertSame(x, y), but additionally recording (using + * threadRecordFailure) any AssertionError thrown, so that the + * current testcase will fail. */ - public void threadShouldThrow() { - threadFailed = true; - fail("should throw exception"); + public void threadAssertSame(Object x, Object y) { + try { + assertSame(x, y); + } catch (AssertionError t) { + threadRecordFailure(t); + throw t; + } } /** - * threadFail with message "should throw" + exceptionName + * Calls threadFail with message "should throw exception". */ - public void threadShouldThrow(String exceptionName) { - threadFailed = true; - fail("should throw " + exceptionName); + public void threadShouldThrow() { + threadFail("should throw exception"); } /** - * threadFail with message "Unexpected exception" + * Calls threadFail with message "should throw" + exceptionName. */ - public void threadUnexpectedException() { - threadFailed = true; - fail("Unexpected exception"); + public void threadShouldThrow(String exceptionName) { + threadFail("should throw " + exceptionName); } /** - * threadFail with message "Unexpected exception", with argument + * Calls threadFail with message "Unexpected exception" + ex. */ - public void threadUnexpectedException(Throwable ex) { - threadFailed = true; - ex.printStackTrace(); - fail("Unexpected exception: " + ex); + public void threadUnexpectedException(Throwable t) { + threadRecordFailure(t); + t.printStackTrace(); + // Rethrow, wrapping in an AssertionError if necessary + if (t instanceof RuntimeException) + throw (RuntimeException) t; + else if (t instanceof Error) + throw (Error) t; + else { + AssertionError ae = new AssertionError("unexpected exception: " + t); + t.initCause(t); + throw ae; + } } /** - * 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) { try { exec.shutdown(); - assertTrue(exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue("ExecutorService did not terminate in a timely manner", + exec.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); } catch (SecurityException ok) { // Allowed in case test doesn't have privs } catch (InterruptedException ie) { @@ -342,28 +403,21 @@ public class JSR166TestCase extends Test /** - * fail with message "should throw exception" + * Fails with message "should throw exception". */ public void shouldThrow() { fail("Should throw exception"); } /** - * fail with message "should throw " + exceptionName + * Fails 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 + * Fails with message "Unexpected exception: " + ex. */ public void unexpectedException(Throwable ex) { ex.printStackTrace(); @@ -576,12 +630,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() { @@ -753,6 +808,36 @@ public class JSR166TestCase extends Test } } + /** + * 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