this.trailers = builder.trailers
    this.body = builder.body
    this.socketHandler = builder.socketHandler
    this.webSocketListener = builder.webSocketListener
    this.inTunnel = builder.inTunnel
    this.informationalResponses = builder.informationalResponses
    this.throttleBytesPerPeriod = builder.throttleBytesPerPeriod
    this.throttlePeriodNanos = builder.throttlePeriodNanos

          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 =

     * calls should be attempted on the socket.
     */
    @Throws(IOException::class, InterruptedException::class)
    private fun processTunnelRequests(): Boolean {
      if (!dispatcher.peek().inTunnel) return true // No tunnel requests.

      val socket = MockWebServerSocket(raw)
      while (true) {
        val socketStillGood = processOneRequest(socket)

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

	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;

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

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

        overrideBadImplementation(override = override.override, testItFails = testItFails)
      }

      OverrideParam.Authenticator -> {
        server.enqueue(

  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 -> {