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

/**
 * A policy for how the pool should treat a specific address.
 */
class AddressPolicy(
  /**
   * How many concurrent calls should be possible to make at any time.
   * The pool will routinely try to pre-emptively open connections to satisfy this minimum.
   * Connections will still be closed if they idle beyond the keep-alive but will be replaced.

    assertThat(connectStart.proxy).isEqualTo(Proxy.NO_PROXY)
    val connectEnd = listener.removeUpToEvent<CallEvent.ConnectEnd>()
    assertThat(connectEnd.call).isSameAs(call)
    assertThat(connectEnd.inetSocketAddress).isEqualTo(expectedAddress)
    assertThat(connectEnd.protocol).isEqualTo(Protocol.HTTP_1_1)
  }

  @Test
  fun failedConnect() {
    enableTlsWithTunnel()

            info.reconnecting = true;
            return info;
        }
        return null;
    }
    
    public void completeReconnect(String path, boolean success) {
        HandleInfo info = handles.get(path);
        if (info != null) {
            if (success) {
                info.updateAccessTime();
                info.reconnecting = false;
            } else {

     * Get transport connection
     *
     * @param tc
     *            context to use
     * @param address the server address
     * @param port the port number
     * @param exclusive
     *            whether to acquire an unshared connection
     * @param forceSigning
     *            whether to enforce SMB signing on this connection
     * @return a transport connection to the target
     */

  ) {
    logWithTime("connectFailed: $protocol $ioe")
  }

  override fun connectionAcquired(
    call: Call,
    connection: Connection,
  ) {
    logWithTime("connectionAcquired: $connection")
  }

  override fun connectionReleased(
    call: Call,
    connection: Connection,
  ) {
    logWithTime("connectionReleased")
  }

  override fun requestHeadersStart(call: Call) {

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

/**
 * Manages reuse of HTTP and HTTP/2 connections for reduced network latency. HTTP requests that

  override fun connectionReleased(connection: Connection) {
  }

  override fun connectionConnectionAcquired(connection: RealConnection) {
  }

  override fun connectionConnectionReleased(connection: RealConnection) {
  }

  override fun connectionConnectionClosed(connection: RealConnection) {
  }

  override fun noNewExchanges(connection: RealConnection) {
  }

import okhttp3.internal.indexOf
import okhttp3.internal.intersect

/**
 * Specifies configuration for the socket connection that HTTP traffic travels through. For `https:`
 * URLs, this includes the TLS version and cipher suites to use when negotiating a secure
 * connection.
 *
 * The TLS versions configured in a connection spec are only be used if they are also enabled in the

import okhttp3.internal.isHealthy
import okhttp3.internal.tls.OkHostnameVerifier
import okio.Buffer

/**
 * A connection to a remote web server capable of carrying 1 or more concurrent streams.
 *
 * Connections are shared in a connection pool. Accesses to the connection's state must be guarded
 * by holding a lock on the connection.
 */
class RealConnection internal constructor(
  val taskRunner: TaskRunner,

    // which can satisfy a larger policy
    val connection = routePlanner.plans.first().connection
    val http2Connection = connectHttp2(peer, connection, 5)
    setPolicy(pool, address, AddressPolicy(5))
    assertThat(pool.connectionCount()).isEqualTo(1)

    // Decrease the connection's max so that another connection is needed
    updateMaxConcurrentStreams(http2Connection, 4)