} catch (InterruptedException e) {
          // ok. just stop sleeping.
        }
        if (shouldStop) {
          break;
        }
        interruptee.interrupt();
      }
    }

    void stopInterrupting() {
      shouldStop = true;
    }
  }

  /** Interrupts the current thread after sleeping for the specified delay. */
  static void requestInterruptIn(long time, TimeUnit unit) {

        } catch (InterruptedException e) {
          // ok. just stop sleeping.
        }
        if (shouldStop) {
          break;
        }
        interruptee.interrupt();
      }
    }

    void stopInterrupting() {
      shouldStop = true;
    }
  }

  /** Interrupts the current thread after sleeping for the specified delay. */
  static void requestInterruptIn(long time, TimeUnit unit) {

import org.junit.jupiter.api.Test

/**
 * Integration test to confirm that [TaskRunner] works with a real backend. Business logic is all
 * exercised by [TaskRunnerTest].
 *
 * This test is doing real sleeping with tolerances of 250 ms. Hopefully that's enough for even the
 * busiest of CI servers.
 */
@Tag("Slowish")
class TaskRunnerRealBackendTest {
  private val log = LinkedBlockingDeque<String>()

    assertFalse("Capable of acquiring an additional permit", r.tryAcquire());
    stopwatch.sleepMillis(Integer.MAX_VALUE);
    assertFalse("Capable of acquiring an additional permit after sleeping", r.tryAcquire());
  }

  public void testSimpleRateUpdate() {
    RateLimiter limiter = RateLimiter.create(5.0, 5, SECONDS);
    assertThat(limiter.getRate()).isEqualTo(5.0);
    limiter.setRate(10.0);

    assertFalse("Capable of acquiring an additional permit", r.tryAcquire());
    stopwatch.sleepMillis(Integer.MAX_VALUE);
    assertFalse("Capable of acquiring an additional permit after sleeping", r.tryAcquire());
  }

  public void testSimpleRateUpdate() {
    RateLimiter limiter = RateLimiter.create(5.0, 5, SECONDS);
    assertThat(limiter.getRate()).isEqualTo(5.0);
    limiter.setRate(10.0);

      if (!completedNormally) {
        startAnotherThread()
      }
    }
  }

  /**
   * Returns an immediately-executable task for the calling thread to execute, sleeping as necessary
   * until one is ready. If there are no ready queues, or if other threads have everything under
   * control this will return null. If there is more than a single task ready to execute immediately

    }
    server
      .url("/b")
      .toUrl()
      .openConnection()
      .getInputStream() // Should succeed.
  }

  /**
   * Throttle the request body by sleeping 500ms after every 3 bytes. With a 6-byte request, this
   * should yield one sleep for a total delay of 500ms.
   */
  @Test
  fun throttleRequest() {
    assumeNotWindows()
    server.enqueue(

        }
    }

    /**
     * Applies delay based on the configured interval rules.
     * This method calculates the appropriate delay for the current time
     * and applies it by sleeping the current thread.
     */
    public void delayByRules() {
        final long delay = getDelay();
        if (delay > 0) {
            ThreadUtil.sleep(delay);
        }
    }

    /**

        .url("/a")
        .toUrl()
        .openConnection()
        .getInputStream()
    assertThat(inputStream!!.read()).isEqualTo('B'.code)
  }

  /**
   * Throttle the request body by sleeping 500ms after every 3 bytes. With a 6-byte request, this
   * should yield one sleep for a total delay of 500ms.
   */
  @Test
  fun throttleRequest() {
    assumeNotWindows()
    server.enqueue(

        public MonitorThread(final Process process, final long timeout) {
            this.process = process;
            this.timeout = timeout;
        }

        /**
         * Runs the monitor thread, sleeping for the timeout duration and terminating the process if needed.
         */
        @Override
        public void run() {
            ThreadUtil.sleepQuietly(timeout);

            if (!finished) {