long end = System.nanoTime() + remainingNanos;

      while (true) {
        try {
          // CountDownLatch treats negative timeouts just like zero.
          return latch.await(remainingNanos, NANOSECONDS);
        } catch (InterruptedException e) {
          interrupted = true;
          remainingNanos = end - System.nanoTime();
        }
      }
    } finally {

    if (profileTests) runTestProfiled();
    else super.runTest();
  }

  protected void runTestProfiled() throws Throwable {
    long t0 = System.nanoTime();
    try {
      super.runTest();
    } finally {
      long elapsedMillis = (System.nanoTime() - t0) / (1000L * 1000L);
      if (elapsedMillis >= profileThreshold)
        System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
    }
  }

   * - System.nanoTime() is expensive enough that we want to call it the minimum required number of
   *   times, typically once before invoking a blocking method. This often requires keeping track of
   *   the first time in a method that nanoTime() has been invoked, for which the special value 0L
   *   is reserved to mean "uninitialized". If timeout is non-positive, then nanoTime need never be
   *   called.

 * (by default) uses {@link System#nanoTime}, it is unaffected by these changes.
 *
 * <p>Use this class instead of direct calls to {@link System#nanoTime} for two reasons:
 *
 * <ul>
 *   <li>The raw {@code long} values returned by {@code nanoTime} are meaningless and unsafe to use
 *       in any other way than how {@code Stopwatch} uses them.

 * (by default) uses {@link System#nanoTime}, it is unaffected by these changes.
 *
 * <p>Use this class instead of direct calls to {@link System#nanoTime} for two reasons:
 *
 * <ul>
 *   <li>The raw {@code long} values returned by {@code nanoTime} are meaningless and unsafe to use
 *       in any other way than how {@code Stopwatch} uses them.

  @SuppressWarnings("removal") // b/260137033
  public static void awaitDone(Future<?> future) {
    if (future.isDone()) {
      return;
    }
    long timeoutSeconds = timeoutSeconds();
    long deadline = System.nanoTime() + SECONDS.toNanos(timeoutSeconds);
    do {
      System.runFinalization();
      if (future.isDone()) {
        return;
      }
      System.gc();
      try {
        future.get(1L, SECONDS);

   *
   * @since 10.0
   */
  public static Ticker systemTicker() {
    return SYSTEM_TICKER;
  }

  private static final Ticker SYSTEM_TICKER =
      new Ticker() {
        @Override
        @SuppressWarnings("GoodTime") // reading system time without TimeSource
        public long read() {
          return System.nanoTime();
        }
      };

    if (profileTests) runTestProfiled();
    else super.runTest();
  }

  protected void runTestProfiled() throws Throwable {
    long t0 = System.nanoTime();
    try {
      super.runTest();
    } finally {
      long elapsedMillis = (System.nanoTime() - t0) / (1000L * 1000L);
      if (elapsedMillis >= profileThreshold)
        System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
    }
  }

          public Boolean get() {
            // Check that this method is called exactly once, by the first
            // thread to synchronize.
            long t0 = System.nanoTime();
            while (waitingThreads() != numThreads - 1) {
              if (System.nanoTime() - t0 > timeout) {
                thrown.set(
                    new TimeoutException(
                        "timed out waiting for other threads to block"

          public Boolean get() {
            // Check that this method is called exactly once, by the first
            // thread to synchronize.
            long t0 = System.nanoTime();
            while (waitingThreads() != numThreads - 1) {
              if (System.nanoTime() - t0 > timeout) {
                thrown.set(
                    new TimeoutException(
                        "timed out waiting for other threads to block"