/**
  * 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);
 }