// For now, skip actual send implementation
            } catch (Exception e) {
                log.error("Failed to redistribute operation", e);
                // Notify waiting threads of failure if the operation supports it
                if (op instanceof CommonServerMessageBlock) {
                    // Handle operation failure appropriately
                    notifyOperationFailure(op, e);

   * Creates a TimeLimiter instance using the given executor service to execute method calls.
   *
   * <p><b>Warning:</b> using a bounded executor may be counterproductive! If the thread pool fills
   * up, any time callers spend waiting for a thread may count toward their time limit, and in this
   * case the call may even time out before the target method is ever invoked.
   *

    // We don't want to leave stray threads running after each test. At this point, every thread
    // launched by this test is either:
    //
    // (a) Blocked attempting to enter the monitor.
    // (b) Waiting for the single guard to become satisfied.
    // (c) Occupying the monitor and awaiting the tearDownLatch.
    //
    // Except for (c), every thread should occupy the monitor very briefly, and every thread leaves

    protected AtomicLong documentSize = new AtomicLong(0);

    /** Total execution time for all operations */
    protected volatile long executeTime = 0;

    /** List of documents waiting to be indexed */
    protected final DocList docList = new DocList();

    /** Maximum size of document requests in bytes */
    protected long maxDocumentRequestSize;

    TimeoutException e =
        assertThrows(
            TimeoutException.class, () -> service.startAsync().awaitRunning(1, MILLISECONDS));
    assertThat(e)
        .hasMessageThat()
        .isEqualTo("Timed out waiting for Foo [STARTING] to reach the RUNNING state.");
  }

  private class FakeService extends AbstractExecutionThreadService implements TearDown {

    private final ExecutorService executor = newSingleThreadExecutor();

            // so when oldFuture completes it is safe to allow the next submitted task to
            // proceed. Doing this immediately here lets the next task run without waiting for
            // the cancelled task's executor to run the noop AsyncCallable.
            //
            // ---
            //

    @SuppressWarnings("unused") // https://errorprone.info/bugpattern/FutureReturnValueIgnored
    Future<?> possiblyIgnoredError = threadPool.submit(new Interrupter(currentThread()));
    try {
      // if waiting works, this should get stuck
      Queues.drain(q, new ArrayList<>(), 1, MAX_VALUE, NANOSECONDS);
      fail();
    } catch (InterruptedException expected) {

     * returned.
     *
     * If upstream would be selected but another thread is already reading upstream this will
     * block until that read completes. It is possible to time out while waiting for that.
     */
    @Throws(IOException::class)
    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      check(fileOperator != null)

      val source: Int =

            destoryTimer.schedule(task, commandTimeout);
            ist.start();

            if (logger.isDebugEnabled()) {
                logger.debug("Waiting for {}.", getName());
            }

            if (p.waitFor(commandTimeout + commandDestroyTimeout, TimeUnit.MILLISECONDS)) {
                if (task.isExecuted()) {

  void awaitTimedWaiting(Thread thread) {
    while (true) {
      switch (thread.getState()) {
        case BLOCKED:
        case NEW:
        case RUNNABLE:
        case WAITING:
          Thread.yield();
          break;
        case TIMED_WAITING:
          return;
        case TERMINATED:
          throw new AssertionError();
      }
    }
  }