* This message is sent to negotiate SMB Direct protocol parameters.
 */
public class SmbDirectNegotiateRequest {

    // Protocol constants
    /** Minimum supported SMB Direct protocol version (1.0) */
    public static final int MIN_VERSION = 0x0100; // SMB Direct 1.0
    /** Maximum supported SMB Direct protocol version (1.0) */
    public static final int MAX_VERSION = 0x0100; // SMB Direct 1.0

    }
  }

  override fun protocol(): Protocol = protocol

  override fun toString(): String =
    "Connection{${route.address.url.host}:${route.address.url.port}," +
      " proxy=${route.proxy}" +
      " hostAddress=${route.socketAddress}" +
      " cipherSuite=${handshake?.cipherSuite ?: "none"}" +
      " protocol=$protocol}"

  companion object {

  ): Request? {
    // Does the client allow redirects?
    if (!chain.followRedirects) return null

    val location = userResponse.header("Location") ?: return null
    // Don't follow redirects to unsupported protocols.
    val url = userResponse.request.url.resolve(location) ?: return null

    // If configured, don't follow redirects between SSL and non-SSL.
    val sameScheme = url.scheme == userResponse.request.url.scheme

    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
  ) {
    logWithTime("connectEnd: $protocol")
  }

  override fun connectFailed(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
    ioe: IOException,
  ) {
    logWithTime("connectFailed: $protocol $ioe")
  }

  override fun connectionAcquired(
    call: Call,

        // Protocol errors
        INVALID_PARAMETER("Invalid parameter", ErrorCategory.PROTOCOL, false), NOT_SUPPORTED("Operation not supported",
                ErrorCategory.PROTOCOL, false), INVALID_PROTOCOL("Invalid protocol", ErrorCategory.PROTOCOL,
                        false), MESSAGE_TOO_LARGE("Message too large", ErrorCategory.PROTOCOL, false),

        // Resource errors

    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
  ) {
    logWithTime("connectEnd: $protocol")
  }

  override fun connectFailed(
    call: Call,
    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
    ioe: IOException,
  ) {
    logWithTime("connectFailed: $protocol $ioe")
  }

  override fun connectionAcquired(
    call: Call,

            .url(url)
            .build();
    try (Response response = client.newCall(request).execute()) {
      assertTrue(response.code() == 200 || response.code() == 404);
      assertEquals(Protocol.HTTP_2, response.protocol());

      for (Certificate c: response.handshake().peerCertificates()) {
        X509Certificate x = (X509Certificate) c;
        System.out.println(x.getSubjectDN());
      }
    }
  }

        synchronized (PROTOCOL_HANDLERS) {
            URLStreamHandler handler = PROTOCOL_HANDLERS.get(protocol);
            if (handler != null) {
                return handler;
            }
            if (factory != null) {
                handler = factory.createURLStreamHandler(protocol);
            }
            if (handler == null) {

    }

    @Test
    @DisplayName("Should handle null protocol ID")
    void testNullProtocolId() {
        // Protocol ID is a constant in transform header, not settable
        // This test is not applicable - the protocol ID is always TRANSFORM_PROTOCOL_ID
        assertTrue(true);
    }

    @Test
    @DisplayName("Should handle invalid protocol ID length")

      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)