SocketPolicy.FAIL_HANDSHAKE -> 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,
        ),
      )

  }

  @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("/"))

          )
        }

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

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

    assertThat(executor.takeException()).isEqualTo(boom)
  }

  @Test
  fun networkInterceptorReturnsConnectionOnEmptyBody() {
    server.enqueue(
      MockResponse
        .Builder()
        .onResponseEnd(ShutdownConnection)
        .addHeader("Connection", "Close")
        .build(),
    )
    val interceptor =
      Interceptor { chain: Interceptor.Chain ->
        val response = chain.proceed(chain.request())

  }

  @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(

   */
  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())