result.headers(headers)
  result.trailers(trailers)

  when (socketPolicy) {
    SocketPolicy.EXPECT_CONTINUE, SocketPolicy.CONTINUE_ALWAYS -> result.add100Continue()
    SocketPolicy.UPGRADE_TO_SSL_AT_END -> result.inTunnel()
    SocketPolicy.SHUTDOWN_SERVER_AFTER_RESPONSE -> result.shutdownServer(true)
    SocketPolicy.KEEP_OPEN -> Unit
    SocketPolicy.DISCONNECT_AT_END -> result.onResponseEnd(ShutdownConnection)

          handshakeCertificates.trustManager,
        ).proxy(server.proxyAddress)
        .build()

    server.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .build(),
    )
    server.enqueue(MockResponse())

    val call =
      client.newCall(
        Request(
          url =
            server
              .url("/")

      MockResponse
        .Builder()
        .code(407)
        .headers(headersOf("Proxy-Authenticate", "Basic realm=\"localhost\""))
        .inTunnel()
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .build(),
    )
    server.enqueue(
      MockResponse(body = "response body"),
    )
    client =
      client

    server.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .code(407)
        .addHeader("Proxy-Authenticate: Basic realm=\"localhost\"")
        .addHeader("Connection: close")
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .build(),
    )
    server.enqueue(MockResponse())
    client =

    val queueDispatcher = QueueDispatcher()
    queueDispatcher.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .build(),
    )
    queueDispatcher.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .build(),
    )
    queueDispatcher.enqueue(MockResponse(body = "call2 response"))

      MockResponse
        .Builder()
        .code(407)
        .headers(headersOf("Proxy-Authenticate", "Basic realm=\"localhost\""))
        .inTunnel()
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .build(),
    )
    server.enqueue(MockResponse(body = "A"))
    client =
      client
        .newBuilder()

	public final fun headers (Lokhttp3/Headers;)Lmockwebserver3/MockResponse$Builder;
	public final fun headersDelay (JLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse$Builder;
	public final fun inTunnel ()Lmockwebserver3/MockResponse$Builder;
	public final fun onRequestBody (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;

    This is only relevant for duplex request bodies, because they are written concurrently when
    reading the response body.

 *  New: `MockResponse.inTunnel()` is a new `mockwebserver3` API to configure responses that are
    served while creating a proxy tunnel. This obsoletes both the `tunnelProxy` argument on