< prev index next >
test/jdk/java/util/concurrent/tck/JSR166TestCase.java
Print this page
8211283: Miscellaneous changes imported from jsr166 CVS 2018-11
Reviewed-by: martin, chegar
@@ -142,17 +142,25 @@
* JUnit does not otherwise arrange). The rules for creating such
* tests are:
*
* <ol>
*
- * <li>All assertions in code running in generated threads must use
- * the forms {@link #threadFail}, {@link #threadAssertTrue}, {@link
- * #threadAssertEquals}, or {@link #threadAssertNull}, (not
- * {@code fail}, {@code assertTrue}, etc.) It is OK (but not
- * particularly recommended) for other code to use these forms too.
+ * <li>All code not running in the main test thread (manually spawned threads
+ * or the common fork join pool) must be checked for failure (and completion!).
+ * Mechanisms that can be used to ensure this are:
+ * <ol>
+ * <li>Signalling via a synchronizer like AtomicInteger or CountDownLatch
+ * that the task completed normally, which is checked before returning from
+ * the test method in the main thread.
+ * <li>Using the forms {@link #threadFail}, {@link #threadAssertTrue},
+ * or {@link #threadAssertNull}, (not {@code fail}, {@code assertTrue}, etc.)
* Only the most typically used JUnit assertion methods are defined
* this way, but enough to live with.
+ * <li>Recording failure explicitly using {@link #threadUnexpectedException}
+ * or {@link #threadRecordFailure}.
+ * <li>Using a wrapper like CheckedRunnable that uses one the mechanisms above.
+ * </ol>
*
* <li>If you override {@link #setUp} or {@link #tearDown}, make sure
* to invoke {@code super.setUp} and {@code super.tearDown} within
* them. These methods are used to clear and check for thread
* assertion failures.
@@ -1316,76 +1324,65 @@
}
/**
* Spin-waits up to the specified number of milliseconds for the given
* thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
+ * @param waitingForGodot if non-null, an additional condition to satisfy
*/
- void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
- long startTime = 0L;
- for (;;) {
- Thread.State s = thread.getState();
- if (s == Thread.State.BLOCKED ||
- s == Thread.State.WAITING ||
- s == Thread.State.TIMED_WAITING)
+ void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis,
+ Callable<Boolean> waitingForGodot) {
+ for (long startTime = 0L;;) {
+ switch (thread.getState()) {
+ default: break;
+ case BLOCKED: case WAITING: case TIMED_WAITING:
+ try {
+ if (waitingForGodot == null || waitingForGodot.call())
return;
- else if (s == Thread.State.TERMINATED)
+ } catch (Throwable fail) { threadUnexpectedException(fail); }
+ break;
+ case TERMINATED:
fail("Unexpected thread termination");
- else if (startTime == 0L)
+ }
+
+ if (startTime == 0L)
startTime = System.nanoTime();
else if (millisElapsedSince(startTime) > timeoutMillis) {
- threadAssertTrue(thread.isAlive());
+ assertTrue(thread.isAlive());
+ if (waitingForGodot == null
+ || thread.getState() == Thread.State.RUNNABLE)
fail("timed out waiting for thread to enter wait state");
+ else
+ fail("timed out waiting for condition, thread state="
+ + thread.getState());
}
Thread.yield();
}
}
/**
* Spin-waits up to the specified number of milliseconds for the given
- * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
- * and additionally satisfy the given condition.
+ * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
*/
- void waitForThreadToEnterWaitState(
- Thread thread, long timeoutMillis, Callable<Boolean> waitingForGodot) {
- long startTime = 0L;
- for (;;) {
- Thread.State s = thread.getState();
- if (s == Thread.State.BLOCKED ||
- s == Thread.State.WAITING ||
- s == Thread.State.TIMED_WAITING) {
- try {
- if (waitingForGodot.call())
- return;
- } catch (Throwable fail) { threadUnexpectedException(fail); }
- }
- else if (s == Thread.State.TERMINATED)
- fail("Unexpected thread termination");
- else if (startTime == 0L)
- startTime = System.nanoTime();
- else if (millisElapsedSince(startTime) > timeoutMillis) {
- threadAssertTrue(thread.isAlive());
- fail("timed out waiting for thread to enter wait state");
- }
- Thread.yield();
- }
+ void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
+ waitForThreadToEnterWaitState(thread, timeoutMillis, null);
}
/**
* Spin-waits up to LONG_DELAY_MS milliseconds for the given thread to
* enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
*/
void waitForThreadToEnterWaitState(Thread thread) {
- waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
+ waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, null);
}
/**
* Spin-waits up to LONG_DELAY_MS milliseconds for the given thread to
* enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
* and additionally satisfy the given condition.
*/
- void waitForThreadToEnterWaitState(
- Thread thread, Callable<Boolean> waitingForGodot) {
+ void waitForThreadToEnterWaitState(Thread thread,
+ Callable<Boolean> waitingForGodot) {
waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, waitingForGodot);
}
/**
* Returns the number of milliseconds since time given by
@@ -1489,30 +1486,32 @@
}
public final void run() {
try {
realRun();
- threadShouldThrow(exceptionClass.getSimpleName());
} catch (Throwable t) {
if (! exceptionClass.isInstance(t))
threadUnexpectedException(t);
+ return;
}
+ threadShouldThrow(exceptionClass.getSimpleName());
}
}
public abstract class CheckedInterruptedRunnable implements Runnable {
protected abstract void realRun() throws Throwable;
public final void run() {
try {
realRun();
- threadShouldThrow("InterruptedException");
} catch (InterruptedException success) {
threadAssertFalse(Thread.interrupted());
+ return;
} catch (Throwable fail) {
threadUnexpectedException(fail);
}
+ threadShouldThrow("InterruptedException");
}
}
public abstract class CheckedCallable<T> implements Callable<T> {
protected abstract T realCall() throws Throwable;
@@ -1520,30 +1519,12 @@
public final T call() {
try {
return realCall();
} catch (Throwable fail) {
threadUnexpectedException(fail);
- return null;
- }
- }
- }
-
- public abstract class CheckedInterruptedCallable<T>
- implements Callable<T> {
- protected abstract T realCall() throws Throwable;
-
- public final T call() {
- try {
- T result = realCall();
- threadShouldThrow("InterruptedException");
- return result;
- } catch (InterruptedException success) {
- threadAssertFalse(Thread.interrupted());
- } catch (Throwable fail) {
- threadUnexpectedException(fail);
}
- return null;
+ throw new AssertionError("unreached");
}
}
public static class NoOpRunnable implements Runnable {
public void run() {}
@@ -1654,18 +1635,10 @@
public static class NPETask implements Callable<String> {
public String call() { throw new NullPointerException(); }
}
- public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
- protected void realRun() {
- try {
- delay(SMALL_DELAY_MS);
- } catch (InterruptedException ok) {}
- }
- }
-
public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
return new CheckedRunnable() {
protected void realRun() {
try {
delay(timeoutMillis);
@@ -1717,12 +1690,12 @@
@Override protected final T compute() {
try {
return realCompute();
} catch (Throwable fail) {
threadUnexpectedException(fail);
- return null;
}
+ throw new AssertionError("unreached");
}
}
/**
* For use as RejectedExecutionHandler in constructors
< prev index next >