assertTrue(context.isEstablished());
        assertArrayEquals(serverChallenge, context.getServerChallenge());
        // Signing key may or may not be generated depending on flags negotiation
        // The context negotiates flags with server, so we can't guarantee signing key
    }

    @Test
    void testInitSecContext_state2_withoutSigning() throws Exception {

_2025-10-07_

 *  New: Support [HTTP 101] responses with `Response.socket`. This mechanism is only supported on
    HTTP/1.1. We also reimplemented our websocket client to use this new mechanism.

 *  New: The `okhttp-zstd` module negotiates [Zstandard (zstd)][zstd] compression with servers that
    support it. It integrates a new (unstable) [ZSTD-KMP] library, also from Square. Enable it like
    this:

    ```kotlin
    val client = OkHttpClient.Builder()

- Improved how the API server responds to **list** requests where the response format negotiates to Protobuf. List responses in Protobuf are marshalled one element at the time, drastically reducing memory needed to serve large collections. Streaming list responses can be disabled via the `StreamingCollectionEncodingToProtobuf` feature gate....

     */
    @Override
    public byte[] getServerEncryptionKey() {
        if (this.negotiated == null) {
            return null;
        }

        if (this.negotiated instanceof SmbComNegotiateResponse) {
            return ((SmbComNegotiateResponse) this.negotiated).getServerData().encryptionKey;
        }
        return null;
    }

    @Override

    }

    /**
     * Returns the server capabilities negotiated during the SMB handshake.
     *
     * @return the negotiated capabilities
     */
    public int getNegotiatedCapabilities() {
        return this.capabilities;
    }

    /**
     * Gets the negotiated send buffer size.
     *
     * @return negotiated send buffer size
     */
    public int getNegotiatedSendBufferSize() {

    }

    /**
     * Get the negotiated SMB Direct protocol version
     *
     * @return negotiated protocol version
     */
    public int getNegotiatedVersion() {
        return negotiatedVersion;
    }

    /**
     * Set the negotiated SMB Direct protocol version
     *
     * @param negotiatedVersion negotiated protocol version
     */

     *
     * @return the security mode flags from the server
     */
    public int getSecurityMode() {
        return this.securityMode;
    }

    /**
     * Gets the negotiated SMB dialect
     *
     * @return the SMB dialect negotiated with the server
     */
    public int getDialect() {
        return this.dialect;
    }

    /**
     * {@inheritDoc}
     *

                log.debug("Multiple preauth negotiate contexts");
                return false;
            }
        }

        if (!foundPreauth) {
            log.error("Missing preauth negotiate context");
            return false;
        }
        if (!foundEnc && (caps & Smb2Constants.SMB2_GLOBAL_CAP_ENCRYPTION) != 0) {
            log.error("Missing encryption negotiate context");
            return false;

    }

    private void negotiate(int port, final ServerMessageBlock resp) throws IOException {
        /* We cannot use Transport.sendrecv() yet because
         * the Transport thread is not setup until doConnect()
         * returns and we want to supress all communication
         * until we have properly negotiated.
         */
        synchronized (sbuf) {
            if (port == 139) {

   * HTTPS.
   */
  fun handshake(): Handshake?

  /**
   * Returns the protocol negotiated by this connection, or [Protocol.HTTP_1_1] if no protocol
   * has been negotiated. This method returns [Protocol.HTTP_1_1] even if the remote peer is using
   * [Protocol.HTTP_1_0].
   */
  fun protocol(): Protocol