?.let { Platform.Companion.get().getHandshakeServerNames(it) }
        ?: listOf()

  fun shutdownInput() {
    javaNetSocket.shutdownInput()
  }

  fun shutdownOutput() {
    javaNetSocket.shutdownOutput()
  }

  /** Sleeps [nanos], throwing if the socket is closed before that period has elapsed. */
  fun sleepWhileOpen(nanos: Long) {
    var ms = nanos / 1_000_000L

) : SSLSocket() {
  @Throws(IOException::class)
  override fun shutdownInput() {
    delegate!!.shutdownInput()
  }

  @Throws(IOException::class)
  override fun shutdownOutput() {
    delegate!!.shutdownOutput()
  }

  override fun getSupportedCipherSuites(): Array<String> = delegate!!.supportedCipherSuites

  override fun getEnabledCipherSuites(): Array<String> = delegate!!.enabledCipherSuites

   * Using this as [MockResponse.onResponseEnd] is the default for HTTP/1.0.
   */
  public class CloseSocket(
    public val closeSocket: Boolean = true,
    public val shutdownInput: Boolean = false,
    public val shutdownOutput: Boolean = false,
  ) : SocketEffect

  /**
   * On HTTP/2, send a [GOAWAY frame](https://tools.ietf.org/html/rfc7540#section-6.8) immediately

          shutdownInput = true,
        ),
      )
    SocketPolicy.SHUTDOWN_OUTPUT_AT_END ->
      result.onResponseEnd(
        CloseSocket(
          closeSocket = false,
          shutdownOutput = true,
        ),
      )
    SocketPolicy.STALL_SOCKET_AT_START -> result.onRequestStart(SocketEffect.Stall)
    SocketPolicy.NO_RESPONSE -> result.onResponseStart(SocketEffect.Stall)

        ).build()

    server.enqueue(
      MockResponse
        .Builder()
        .body("a")
        .onResponseEnd(
          CloseSocket(
            closeSocket = false,
            shutdownOutput = true,
          ),
        ).build(),
    )
    server.enqueue(MockResponse(body = "b"))

    val requestA = Request(server.url("/"))
    val responseA = client.newCall(requestA).execute()

        } else {
          socket.close()
        }
      }

      is CloseSocket -> {
        if (effect.shutdownInput) socket.shutdownInput()
        if (effect.shutdownOutput) socket.shutdownOutput()
        if (effect.closeSocket) socket.close()
      }

      Stall -> {
        // Sleep until the socket is closed.
        socket.sleepWhileOpen(TimeUnit.MINUTES.toNanos(60))

        .Builder(true, TaskRunner.INSTANCE)
        .socket(socket.asBufferedSocket(), "peer")
        .pushObserver(IGNORE)
        .build()
    connection.start(sendConnectionPreface = false)
    socket.shutdownOutput()
    assertFailsWith<IOException> {
      connection.newStream(headerEntries("a", longString), false)
    }
    assertFailsWith<IOException> {
      connection.newStream(headerEntries("b", longString), false)

      MockResponse
        .Builder()
        .body("This connection won't pool properly")
        .onResponseEnd(
          CloseSocket(
            closeSocket = false,
            shutdownOutput = true,
          ),
        ).build(),
    )
  }

  @Test
  fun invalidHost() {
    // Note that 1234.1.1.1 is an invalid host in a URI, but URL isn't as strict.
    client =
      client

    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(
      MockResponse
        .Builder()
        .onResponseStart(
          CloseSocket(
            closeSocket = false,
            shutdownOutput = true,
          ),
        ).build(),
    )
    server.enqueue(MockResponse(body = "abc"))

    val client =
      client
        .newBuilder()
        .retryOnConnectionFailure(false)