val fancyRequest =
      Request.Builder()
        .url("$scheme://$authority/")
        .headers(request.headers)
        .build()
    val fancyResponse =
      Response.Builder()
        .code(webSocketResponse.code)
        .message(webSocketResponse.message)
        .headers(webSocketResponse.headers)
        .request(fancyRequest)
        .protocol(Protocol.HTTP_1_1)
        .build()

    private val response =
      Response.Builder()
        .request(Request("https://example.com/".toHttpUrl()))
        .protocol(Protocol.HTTP_1_1)
        .message("OK")
        .code(200)
        .body(
          object : ResponseBody() {
            override fun contentType() = null

            override fun contentLength() = -1L

            override fun source() =

        .header("User-Agent", USER_AGENT)
        .build()

    val fakeAuthChallengeResponse =
      Response.Builder()
        .request(proxyConnectRequest)
        .protocol(Protocol.HTTP_1_1)
        .code(HttpURLConnection.HTTP_PROXY_AUTH)
        .message("Preemptive Authenticate")
        .sentRequestAtMillis(-1L)
        .receivedResponseAtMillis(-1L)
        .header("Proxy-Authenticate", "OkHttp-Preemptive")

  // This ensures that we never wait for a blocking operation while holding 'this'.

  /** True if this peer initiated the connection. */
  internal val client: Boolean = builder.client

  /** User code to run in response to incoming streams or settings. */
  internal val listener: Listener = builder.listener
  internal val streams = mutableMapOf<Int, Http2Stream>()
  internal val connectionName: String = builder.connectionName

    v1Creator.commit()

    cache["k1"]!!.use { snapshot1 ->
      val inV1 = snapshot1.getSource(0).buffer()
      assertThat(inV1.readByte()).isEqualTo('A'.code.toByte())
      assertThat(inV1.readByte()).isEqualTo('A'.code.toByte())

      val v1Updater = cache.edit("k1")!!
      v1Updater.setString(0, "CCcc")
      v1Updater.setString(1, "DDdd")
      v1Updater.commit()

    fun isCacheable(
      response: Response,
      request: Request,
    ): Boolean {
      // Always go to network for uncacheable response codes (RFC 7231 section 6.1), This
      // implementation doesn't support caching partial content.
      when (response.code) {
        HTTP_OK,
        HTTP_NOT_AUTHORITATIVE,
        HTTP_NO_CONTENT,
        HTTP_MULT_CHOICE,
        HTTP_MOVED_PERM,
        HTTP_NOT_FOUND,

 * <http://www.apache.org/>.
 */

package okhttp3.internal.http

// HTTP Status Codes not offered by HttpUrlConnection.
//
// https://datatracker.ietf.org/doc/html/rfc7231#page-47
//
// From https://github.com/apache/httpcomponents-core/blob/master/httpcore5/src/main/java/org/apache/hc/core5/http/HttpStatus.java

/** `100 Continue` (HTTP/1.1 - RFC 7231)  */

  }

  /**
   * Prunes any leaked calls and then returns the number of remaining live calls on [connection].
   * Calls are leaked if the connection is tracking them but the application code has abandoned
   * them. Leak detection is imprecise and relies on garbage collection.
   */
  private fun pruneAndGetAllocationCount(
    connection: RealConnection,
    now: Long,
  ): Int {

     * classes include special optimizations that can be lost if the implementations are decorated.
     *
     * If necessary, you can create and configure the defaults yourself with the following code:
     *
     * ```java
     * TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(
     * TrustManagerFactory.getDefaultAlgorithm());
     * trustManagerFactory.init((KeyStore) null);

	public final fun -deprecated_body ()Lokhttp3/ResponseBody;
	public final fun -deprecated_cacheControl ()Lokhttp3/CacheControl;
	public final fun -deprecated_cacheResponse ()Lokhttp3/Response;
	public final fun -deprecated_code ()I
	public final fun -deprecated_handshake ()Lokhttp3/Handshake;
	public final fun -deprecated_headers ()Lokhttp3/Headers;
	public final fun -deprecated_message ()Ljava/lang/String;