.assertSuccessful()
      .assertCode(200)
  }

  private fun enableProtocol(protocol: Protocol) {
    enableTls()
    client =
      client.newBuilder()
        .protocols(listOf(protocol, Protocol.HTTP_1_1))
        .build()
    server1.protocols = client.protocols
    server2.protocols = client.protocols
  }

  private fun enableTls() {
    client =
      client.newBuilder()

    }

    /**
     * Get the protocol of the proxy server.
     *
     * @return the protocol of the proxy server
     */
    public String getProtocol() {
        return protocol;
    }

    /**
     * @param protocol the protocol of the proxy server like <i>SOCKSv4</i>
     */
    public void setProtocol(String protocol) {
        this.protocol = protocol;
    }

    val s = sslSocket as BCSSLSocket

    return when (val protocol = s.applicationProtocol) {
      null, "" -> null
      else -> protocol
    }
  }

  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {
    // No TLS extensions if the socket class is custom.
    if (matchesSocket(sslSocket)) {

        final String value = System.getProperty("java.protocol.handler.pkgs");
        if (StringUtil.isEmpty(value)) {
            buf.append("org.codelibs.fess.net.protocol");
        } else if (!value.contains("org.codelibs.fess.net.protocol")) {
            buf.append("|org.codelibs.fess.net.protocol");
        }
        if (buf.length() > 0) {
            System.setProperty("java.protocol.handler.pkgs", buf.toString());
        }
    }

    return try {
      // SSLSocket.getApplicationProtocol returns "" if application protocols values will not
      // be used. Observed if you didn't specify SSLParameters.setApplicationProtocols
      when (val protocol = sslSocket.applicationProtocol) {
        null, "" -> null
        else -> protocol
      }
    } catch (e: UnsupportedOperationException) {

        val sslSocket = doSsl(socket)
        val protocolString = Platform.get().getSelectedProtocol(sslSocket)
        val protocol = if (protocolString != null) get(protocolString) else null
        if (protocol != Protocol.HTTP_2) {
          throw ProtocolException("Protocol $protocol unsupported")
        }
        val connection =
          Http2Connection.Builder(false, TaskRunner.INSTANCE)
            .socket(sslSocket)

  body.close()
}

fun Response.commonToString(): String = "Response{protocol=$protocol, code=$code, message=$message, url=${request.url}}"

fun Response.Builder.commonRequest(request: Request) =
  apply {
    this.request = request
  }

fun Response.Builder.commonProtocol(protocol: Protocol) =
  apply {
    this.protocol = protocol
  }

fun Response.Builder.commonCode(code: Int) =
  apply {

    private static URLStreamHandler getDefaultStreamHandler ( String protocol ) throws IOException {
        synchronized ( PROTOCOL_HANDLERS ) {
            URLStreamHandler handler = PROTOCOL_HANDLERS.get(protocol);
            if ( handler != null )
                return handler;
            if ( factory != null ) {
                handler = factory.createURLStreamHandler(protocol);
            }
            if ( handler == null ) {

import java.net.ProtocolException
import okhttp3.Protocol
import okhttp3.Response
import okio.IOException

/** An HTTP response status line like "HTTP/1.1 200 OK". */
class StatusLine(
  @JvmField val protocol: Protocol,
  @JvmField val code: Int,
  @JvmField val message: String,
) {
  override fun toString(): String {
    return buildString {
      if (protocol == Protocol.HTTP_1_0) {
        append("HTTP/1.0")
      } else {

{
  "workloads": {
    "network1/10.244.2.54": {
      "workloadIps": [
        "10.244.2.54"
      ],
      "waypoint": {
        "destination": "/10.96.65.117",
        "port": 15008
      },
      "protocol": "HBONE",
      "uid": "Kubernetes//Pod/bookinfo/ratings-v1-6484c4d9bb-mdxm5",
      "name": "ratings-v1-6484c4d9bb-mdxm5",
      "namespace": "bookinfo",
      "trustDomain": "cluster.local",