private static void joinUninterruptibly(Thread thread, long timeout, TimeUnit unit) {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(timeout);
      long end = System.nanoTime() + remainingNanos;

      while (true) {
        try {
          // TimeUnit.timedJoin() treats negative timeouts just like zero.
          NANOSECONDS.timedJoin(thread, remainingNanos);

        this.maxConnectionsPerRoute = maxConnectionsPerRoute;
    }

    /**
     * Sets the socket timeout in milliseconds.
     *
     * @param soTimeout The socket timeout
     */
    public void setSoTimeout(final Integer soTimeout) {
        this.soTimeout = soTimeout;
    }

    /**
     * Sets the cookie specification to use.
     *

    private final boolean permanent;

    private long startTime;

    private int status = ACTIVE;

    TimeoutTask(final TimeoutTarget timeoutTarget, final int timeout, final boolean permanent) {
        this.timeoutTarget = timeoutTarget;
        this.timeoutMillis = timeout * 1000L;
        this.permanent = permanent;
        this.startTime = System.currentTimeMillis();
    }

    /**
     * Returns whether the task has expired.

  void awaitRunning();

  /**
   * Waits for the {@link Service} to reach the {@linkplain State#RUNNING running state} for no more
   * than the given time.
   *
   * @param timeout the maximum time to wait
   * @param unit the time unit of the timeout argument
   * @throws TimeoutException if the service has not reached the given state within the deadline

    /**
     * Receive data using RDMA
     *
     * @param timeout timeout in milliseconds
     * @return received data buffer, or null if timeout
     * @throws IOException if receive fails
     */
    public abstract ByteBuffer receive(int timeout) throws IOException;

    /**
     * Perform RDMA read operation
     *

import java.util.concurrent.atomic.AtomicBoolean;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;

/**
 * Unit tests for ResourceManager
 */
public class ResourceManagerTest {

    private ResourceManager resourceManager;

    @BeforeEach
    void setUp() {

      override fun connect(
        endpoint: SocketAddress?,
        timeout: Int,
      ) {
        val requested = (endpoint as InetSocketAddress)
        val inetSocketAddress = hostMapping[requested.address] ?: defaultAddress ?: requested
        Platform.get().log("Socket connection to: $inetSocketAddress was: $requested")
        super.connect(inetSocketAddress, timeout)
      }
    }

        fi;
        echo "Waiting for database to be ready... ($$counter/12)";
        sleep 5;
        counter=$$(($$counter + 1));
      done;
      # timeout handling
      if [ $$counter -gt 20 ]; then
        echo "Error: Database failed to start within timeout";
        exit 1;
      fi;
      # keep the container running: wait for the database process in the foreground
      wait

    } else {
      javaNetSocket.soTimeout = chain.readTimeoutMillis()
      okHttpSocket.source.timeout().timeout(chain.readTimeoutMillis.toLong(), MILLISECONDS)
      okHttpSocket.sink.timeout().timeout(chain.writeTimeoutMillis.toLong(), MILLISECONDS)
      Http1ExchangeCodec(client, this, okHttpSocket)
    }
  }

  internal fun useAsSocket() {
    javaNetSocket.soTimeout = 0
    noNewExchanges()
  }

  public V get() throws InterruptedException, ExecutionException {
    return delegate.get();
  }

  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    return delegate.get(timeout, unit);
  }

  @Override
  public String toString() {
    return delegate.toString();
  }