var proxySelector: ProxySelector = RecordingProxySelector()
  var proxyAuthenticator: Authenticator = RecordingOkAuthenticator("password", null)
  var connectionSpecs: List<ConnectionSpec> =
    listOf(
      ConnectionSpec.MODERN_TLS,
      ConnectionSpec.COMPATIBLE_TLS,
      ConnectionSpec.CLEARTEXT,
    )
  var protocols: List<Protocol> =
    listOf(
      Protocol.HTTP_1_1,
    )

      client.newBuilder()
        .hostnameVerifier(RecordingHostnameVerifier())
        .connectionSpecs(
          // Attempt RESTRICTED_TLS then fall back to MODERN_TLS.
          listOf(
            ConnectionSpec.RESTRICTED_TLS,
            ConnectionSpec.MODERN_TLS,
          ),
        )
        .sslSocketFactory(
          suppressTlsFallbackClientSocketFactory(),
          handshakeCertificates.trustManager,

import org.conscrypt.Conscrypt

fun currentOkHttp(ianaSuites: IanaSuites): Client {
  return Client(
    userAgent = "OkHttp",
    version = OkHttp.VERSION,
    enabled =
      ConnectionSpec.MODERN_TLS.cipherSuites!!.map {
        ianaSuites.fromJavaName(it.javaName)
      },
    supported =
      ConnectionSpec.COMPATIBLE_TLS.cipherSuites!!.map {
        ianaSuites.fromJavaName(it.javaName)
      },
  )
}

import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Test

/**
 * Access every type, function, and property from Kotlin to defend against unexpected regressions in
 * modern 4.0.x kotlin source-compatibility.
 */
@Suppress(
  "ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE",
  "UNUSED_ANONYMOUS_PARAMETER",
  "UNUSED_VALUE",
  "UNUSED_VARIABLE",
  "VARIABLE_WITH_REDUNDANT_INITIALIZER",

      }

      HTTP_CLIENT_TIMEOUT -> {
        // 408's are rare in practice, but some servers like HAProxy use this response code. The
        // spec says that we may repeat the request without modifications. Modern browsers also
        // repeat the request (even non-idempotent ones.)
        if (!client.retryOnConnectionFailure) {
          // The application layer has directed us not to retry the request.
          return null

      }
      flowControlListener.receivingConnectionWindowChanged(readBytes)
    }
  }

  /**
   * Returns a new server-initiated stream.
   *
   * @param associatedStreamId the stream that triggered the sender to create this stream.
   * @param out true to create an output stream that we can use to send data to the remote peer.
   *     Corresponds to `FLAG_FIN`.
   */
  @Throws(IOException::class)
  fun pushStream(

  }

  companion object {
    internal val DEFAULT_PROTOCOLS = immutableListOf(HTTP_2, HTTP_1_1)

    internal val DEFAULT_CONNECTION_SPECS =
      immutableListOf(
        ConnectionSpec.MODERN_TLS,
        ConnectionSpec.CLEARTEXT,
      )
  }

	public static final field CLEARTEXT Lokhttp3/ConnectionSpec;
	public static final field COMPATIBLE_TLS Lokhttp3/ConnectionSpec;
	public static final field Companion Lokhttp3/ConnectionSpec$Companion;
	public static final field MODERN_TLS Lokhttp3/ConnectionSpec;
	public static final field RESTRICTED_TLS Lokhttp3/ConnectionSpec;
	public final fun -deprecated_cipherSuites ()Ljava/util/List;
	public final fun -deprecated_supportsTlsExtensions ()Z