try {
            final URLConnection connection = url.openConnection();
            connection.setUseCaches(false);
            return connection.getInputStream();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Returns a {@link URLConnection} object that represents a connection to the remote object referred to by the URL.
     *

            // endpoint.connect(remoteAddress, 1000);  // 1 second timeout

            state = RdmaConnectionState.CONNECTED;
            log.debug("DiSNI RDMA connection established to {}", remoteAddress);

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;
            throw new IOException("DiSNI RDMA connection failed", e);
        }
    }

 */
package okhttp3.internal.connection

import java.io.IOException
import okhttp3.Address
import okhttp3.HttpUrl

/**
 * Policy on choosing which connection to use for an exchange and any retries that follow. This uses
 * the following strategies:
 *
 *  1. If the current call already has a connection that can satisfy the request it is used. Using

 *  * attempt to find a connection
 *  * step through time, asserting that the expected side effects are performed.
 */
internal class FastFallbackExchangeFinderTest {
  private val taskFaker = TaskFaker()
  private val taskRunner = taskFaker.taskRunner

  /**
   * Note that we don't use the same [TaskFaker] for this factory. That way off-topic tasks like

[GC guide](/doc/gc-guide#Linux_transparent_huge_pages), or switch to a Linux
distribution that disables transparent huge pages altogether.

Go 1.22 added contention on runtime-internal locks to the [`mutex`
profile](/pkg/runtime/pprof#Profile). Contention on these locks is always
reported at `runtime._LostContendedRuntimeLock`. Complete stack traces of
runtime locks can be enabled with the [`runtimecontentionstacks`

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

/**
 * A RoutePlanner that will always establish a new connection, ignoring any connection pooling
 */
class ForceConnectRoutePlanner(
  private val delegate: RealRoutePlanner,
) : RoutePlanner by delegate {

import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.connection.ConnectionListener
import okhttp3.internal.connection.FastFallbackExchangeFinder
import okhttp3.internal.connection.ForceConnectRoutePlanner
import okhttp3.internal.connection.RealConnectionPool
import okhttp3.internal.connection.RealRoutePlanner
import okhttp3.internal.connection.RouteDatabase

/**

 * limitations under the License.
 */
package okhttp3.internal.http2

import java.io.IOException

/**
 * Thrown when an HTTP/2 connection is shutdown (either explicitly or if the peer has sent a GOAWAY
 * frame) and an attempt is made to use the connection.
 */

 * It converts Unicode domain names to ASCII Compatible Encoding (ACE) using the
 * {@link java.net.IDN} class.
 *
 * <p>This class allows setting a custom flag for the IDN conversion and a custom
 * encoding for URL decoding.</p>
 *
 * <p>Example usage:</p>
 * <pre>
 * {@code
 * IdnDnsResolver resolver = new IdnDnsResolver();
 * resolver.setFlag(IDN.ALLOW_UNASSIGNED);

    health check fails.


## Version 2.7.0

_2015-12-13_

 *  **Rewritten connection management.** Previously OkHttp's connection pool
    managed both idle and active connections for HTTP/2, but only idle
    connections for HTTP/1.x. With this update the connection pool manages both
    idle and active connections for everything. OkHttp now detects and warns on