/**
* Delays, via Thread.sleep, for the given millisecond delay, but if the sleep is shorter than
* specified, may re-sleep or yield until time elapses.
*/
static void delay(long millis) throws InterruptedException {
long startTime = System.nanoTime();
long ns = millis * 1000 * 1000;
for (; ; ) {
if (millis > 0L) Thread.sleep(millis);
else // too short to sleep
Thread.yield();
long d = ns - (System.nanoTime() - startTime);
if (d > 0L) millis = d / (1000 * 1000);
else break;
}
}
/** Spin-waits until sync.isQueued(t) becomes true. */
void waitForQueuedThread(AbstractQueuedLongSynchronizer sync, Thread t) {
long startTime = System.nanoTime();
while (!sync.isQueued(t)) {
if (millisElapsedSince(startTime) > LONG_DELAY_MS)
throw new AssertionFailedError("timed out");
Thread.yield();
}
assertTrue(t.isAlive());
}
protected void runTestProfiled() throws Throwable {
// Warmup run, notably to trigger all needed classloading.
super.runTest();
long t0 = System.nanoTime();
try {
super.runTest();
} finally {
long elapsedMillis = millisElapsedSince(t0);
if (elapsedMillis >= profileThreshold)
System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
}
}
/** Checks that future.get times out, with the given millisecond timeout. */
void assertFutureTimesOut(Future future, long timeoutMillis) {
long startTime = System.nanoTime();
try {
future.get(timeoutMillis, MILLISECONDS);
shouldThrow();
} catch (TimeoutException success) {
} catch (Exception e) {
threadUnexpectedException(e);
} finally {
future.cancel(true);
}
assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
}
/**
* Spin-waits up to the specified number of milliseconds for the given thread to enter a wait
* state: BLOCKED, WAITING, or TIMED_WAITING.
*/
void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
long startTime = System.nanoTime();
for (; ; ) {
Thread.State s = thread.getState();
if (s == Thread.State.BLOCKED || s == Thread.State.WAITING || s == Thread.State.TIMED_WAITING)
return;
else if (s == Thread.State.TERMINATED) fail("Unexpected thread termination");
else if (millisElapsedSince(startTime) > timeoutMillis) {
threadAssertTrue(thread.isAlive());
return;
}
Thread.yield();
}
}
/** Calling await without holding sync throws IllegalMonitorStateException */
public void testAwait_IMSE() {
final Mutex sync = new Mutex();
final ConditionObject c = sync.newCondition();
for (AwaitMethod awaitMethod : AwaitMethod.values()) {
long startTime = System.nanoTime();
try {
await(c, awaitMethod);
shouldThrow();
} catch (IllegalMonitorStateException success) {
} catch (InterruptedException e) {
threadUnexpectedException(e);
}
assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
}
}
/** Checks that awaiting the given condition times out (using the default timeout duration). */
void assertAwaitTimesOut(ConditionObject c, AwaitMethod awaitMethod) {
long timeoutMillis = timeoutMillis();
long startTime = System.nanoTime();
try {
switch (awaitMethod) {
case awaitTimed:
assertFalse(c.await(timeoutMillis, MILLISECONDS));
break;
case awaitNanos:
long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
long nanosRemaining = c.awaitNanos(nanosTimeout);
assertTrue(nanosRemaining <= 0);
break;
case awaitUntil:
assertFalse(c.awaitUntil(delayedDate(timeoutMillis)));
break;
default:
throw new UnsupportedOperationException();
}
} catch (InterruptedException ie) {
threadUnexpectedException(ie);
}
assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
}
/**
* Returns the number of milliseconds since time given by startNanoTime, which must have been
* previously returned from a call to {@link System.nanoTime()}.
*/
static long millisElapsedSince(long startNanoTime) {
return NANOSECONDS.toMillis(System.nanoTime() - startNanoTime);
}