}
        throw e;
        // The execution of a task has ended abnormally.
        // We could have tasks left in the queue, so should perhaps try to restart a worker,
        // but then the Error will get delayed if we are using a direct (same thread) executor.
      }
    }

    /**
     * Continues executing tasks from {@link #queue} until it is empty.
     *

      notifyStopped();
    }
  }

  /*
   * A NoOp service that will delay the startup and shutdown notification for a configurable amount
   * of time.
   */
  private static class NoOpDelayedService extends NoOpService {
    private final long delay;

    NoOpDelayedService(long delay) {
      this.delay = delay;
    }

    @Override
    protected void doStart() {
      new Thread() {

      }

    public fun headersDelay(
      delay: Long,
      unit: TimeUnit,
    ): Builder =
      apply {
        headersDelayNanos = unit.toNanos(delay)
      }

    /**
     * Set the delayed time of the response body to [delay]. This applies to the response body
     * only; response headers are not affected.
     */
    public fun bodyDelay(
      delay: Long,
      unit: TimeUnit,
    ): Builder =

   * one of those methods.
   */
  open fun responseFailed(
    call: Call,
    ioe: IOException,
  ) {
  }

  /**
   * Invoked immediately after a call has completely ended.  This includes delayed consumption
   * of response body by the caller.
   *
   * This method is always invoked after [callStart].
   */
  open fun callEnd(call: Call) {
  }

  /**

        /** Number of in-flight fetch operations */
        public int numberOfInFlightFetch;
        /** Number of pending tasks */
        public int numberOfPendingTasks;
        /** Number of delayed unassigned shards */
        public int delayedUnassignedShards;
        /** Number of unassigned shards */
        public int unassignedShards;
        /** Number of initializing shards */

   * #waitersField}.
   */
  private final @Nullable Waiter gasWaiters(Waiter update) {
    return ATOMIC_HELPER.gasWaiters(this, update);
  }

  /**
   * Marks the given node as 'deleted' (null waiter) and then scans the list to unlink all deleted
   * nodes. This is an O(n) operation in the common case (and O(n^2) in the worst), but we are saved
   * by two things.
   *
   * <ul>

   * #waitersField}.
   */
  private final @Nullable Waiter gasWaiters(Waiter update) {
    return ATOMIC_HELPER.gasWaiters(this, update);
  }

  /**
   * Marks the given node as 'deleted' (null waiter) and then scans the list to unlink all deleted
   * nodes. This is an O(n) operation in the common case (and O(n^2) in the worst), but we are saved
   * by two things.
   *
   * <ul>

        InetAddress newAddress = newAddresses.get(0).getAddress();
        scheduleAddressChange(newAddress);
    }
}

private void scheduleReconnection(long delayMs) {
    CompletableFuture.delayedExecutor(delayMs, TimeUnit.MILLISECONDS)
        .execute(() -> {
            try {
                transport.disconnect();
                transport.connect();  // Reconnect

     * returns 0, but if we had a SingletonImmutableSortedSet, this might no
     * longer be the case.)
     *
     * javax.naming.Name and java.util.concurrent.Delayed might work, but
     * they're fairly obscure, we've invented our own interface and class.
     */
    Interface a = new Impl();
    Interface b = new Impl();

        // When
        long delay1 = policy.getDelayMs(1);
        long delay2 = policy.getDelayMs(2);
        long delay3 = policy.getDelayMs(3);

        // Then - All delays should be the same
        assertEquals(2000, delay1);
        assertEquals(2000, delay2);
        assertEquals(2000, delay3);
    }

    @Test