this.pushPromises = mockResponse.pushPromises.toMutableList()
      this.settings =
        Settings().apply {
          merge(mockResponse.settings)
        }
    }

    fun code(code: Int) =
      apply {
        this.code = code
      }

    /** Sets the status and returns this. */
    fun status(status: String) =
      apply {
        this.status = status
      }

    /**

          call: Call,
          response: Response,
        ) {
          val bytes = response.body.byteStream()
          assertThat(bytes.read()).isEqualTo('a'.code)
          assertThat(bytes.read()).isEqualTo('b'.code)
          assertThat(bytes.read()).isEqualTo('c'.code)

          // This request will share a connection with 'A' cause it's all done.

        .url("http://publicobject.com/helloworld.txt")
        .build()

    val response1Body =
      client.newCall(request).execute().use {
        if (!it.isSuccessful) throw IOException("Unexpected code $it")

        println("Response 1 response:          $it")
        println("Response 1 cache response:    ${it.cacheResponse}")
        println("Response 1 network response:  ${it.networkResponse}")

    val call = client.newCall(networkRequest)

    call.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNull()
    }

    val cachedCall = client.newCall(request)

    cachedCall.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNotNull()
    }
  }

  private fun assumeNetwork() {

    clientTestRule.newClient().newCall(Request(server.url("/"))).execute().use {
      assertThat(it.code).isEqualTo(200)
    }
  }

  @Test
  fun testClient2(server: MockWebServer) {
    assertThat(server).isSameInstanceAs(instanceServer)

    clientTestRule.newClient().newCall(Request(server.url("/"))).execute().use {
      assertThat(it.code).isEqualTo(200)
    }
  }

  @ParameterizedTest
  @ValueSource(ints = [1, 2])

          .protocol(statusLine.protocol)
          .code(statusLine.code)
          .message(statusLine.message)
          .headers(headersReader.readHeaders())
          .trailers { error("trailers not available") }

      return when {
        expectContinue && statusLine.code == HTTP_CONTINUE -> {
          null
        }
        statusLine.code == HTTP_CONTINUE -> {
          state = STATE_READ_RESPONSE_HEADERS

        .url("https://sni.cloudflaressl.com/cdn-cgi/trace")
        .header("Host", "cloudflare-dns.com")
        .build()
    client.newCall(request).execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)

      assertThat(response.body.string()).contains("h=cloudflare-dns.com")
    }
  }

  @Test
  fun getWithDns() {
    client =

 * `server_max_window_bits`. This harms our ability to support these parameters:
 *
 *  * If `client_max_window_bits` is less than 15, OkHttp must close the web socket with code 1010.
 *    Otherwise it would compress values in a way that servers could not decompress.
 *  * If `server_max_window_bits` is less than 15, OkHttp will waste memory on an oversized buffer.
 *

   FFFE-FFFF; [NONCHARACTER CODE POINTS]
   1FFFE-1FFFF; [NONCHARACTER CODE POINTS]
   2FFFE-2FFFF; [NONCHARACTER CODE POINTS]
   3FFFE-3FFFF; [NONCHARACTER CODE POINTS]
   4FFFE-4FFFF; [NONCHARACTER CODE POINTS]
   5FFFE-5FFFF; [NONCHARACTER CODE POINTS]
   6FFFE-6FFFF; [NONCHARACTER CODE POINTS]
   7FFFE-7FFFF; [NONCHARACTER CODE POINTS]
   8FFFE-8FFFF; [NONCHARACTER CODE POINTS]
   9FFFE-9FFFF; [NONCHARACTER CODE POINTS]

      0x40,
      10,
      'c'.code,
      'u'.code,
      's'.code,
      't'.code,
      'o'.code,
      'm'.code,
      '-'.code,
      'k'.code,
      'e'.code,
      'y'.code,
      13,
      'c'.code,
      'u'.code,
      's'.code,
      't'.code,
      'o'.code,
      'm'.code,
      '-'.code,
      'h'.code,
      'e'.code,
      'a'.code,