.Builder()
        .body("This connection won't pool properly")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
  }

  @Test
  fun serverShutdownInput() {
    testServerClosesOutput(
      MockResponse
        .Builder()
        .body("This connection won't pool properly")
        .onResponseEnd(
          CloseSocket(
            closeSocket = false,

    server.useHttps(serverHandshakeCertificates.sslSocketFactory())

    // The request should complete successfully.
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    val call1 =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )

  }

  @Test
  fun readEmptyTrailersHttp1UnknownLengthResponse() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("Hello")
        .removeHeader("Content-Length")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )

    val call = client.newCall(Request(server.url("/")))
    call.execute().use { response ->
      assertThat(response.headers["Content-Length"]).isNull()

        .addHeader("Connection", "Close")
        .body("You took too long!")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .code(408)
        .addHeader("Connection", "Close")
        .body("You took too long!")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    val request = Request(server.url("/"))

  }

  @Test
  fun connectionsAreNotReusedWithUnknownLengthResponseBody() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("a")
        .clearHeaders()
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    server.enqueue(MockResponse(body = "b"))
    val request = Request(server.url("/"))
    assertConnectionNotReused(request, request)
  }

  @Test

  }

  @Test
  fun connectionNotReusedAfterShutdown() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("ABC")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    server.enqueue(MockResponse(body = "DEF"))
    // Enqueue an additional response that show if we burnt a good prior response.
    server.enqueue(

      result.failHandshake()
    }

    SocketPolicy.SHUTDOWN_INPUT_AT_END -> {
      result.onResponseEnd(
        CloseSocket(
          closeSocket = false,
          shutdownInput = true,
        ),
      )
    }

    SocketPolicy.SHUTDOWN_OUTPUT_AT_END -> {
      result.onResponseEnd(
        CloseSocket(
          closeSocket = false,
          shutdownOutput = true,
        ),

          )
        }

        // See warnings associated with these socket policies in SocketPolicy.
        if (handleSocketEffect(response.onResponseEnd, socket)) {
          return false
        }

        return reuseSocket
      } finally {
        if (response.shutdownServer) {
          close()
        }
      }
    }
  }

   */
  private fun truncateViolently(
    builder: MockResponse.Builder,
    numBytesToKeep: Int,
  ): MockResponse.Builder {
    val response = builder.build()
    builder.onResponseEnd(ShutdownConnection)
    val headers = response.headers
    val fullBody = Buffer()
    response.body!!.writeTo(fullBody)
    val truncatedBody = Buffer()
    truncatedBody.write(fullBody, numBytesToKeep.toLong())