when(httpSession.getAttribute("NtlmHttpAuth")).thenReturn(null);

        // Create a custom filter that overrides negotiate to test skipAuthentication
        NtlmHttpFilter customFilter = new NtlmHttpFilter() {
            @Override
            protected NtlmPasswordAuthentication negotiate(HttpServletRequest req, HttpServletResponse resp, boolean skipAuthentication)
                    throws IOException, ServletException {

        throw new UnsupportedOperationException("RDMA write not supported by TCP fallback");
    }

    @Override
    public RdmaNegotiateResponse negotiate(RdmaNegotiateRequest request) throws IOException {
        // For TCP fallback, we simulate successful negotiation
        RdmaNegotiateResponse response = new RdmaNegotiateResponse();
        response.setStatus(0); // Success

        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 {

  ) {
  }

  /** Called after the TLS handshake to release resources allocated by [configureTlsExtensions]. */
  open fun afterHandshake(sslSocket: SSLSocket) {
  }

  /** Returns the negotiated protocol, or null if no protocol was negotiated. */
  open fun getSelectedProtocol(sslSocket: SSLSocket): String? = null

  /** For MockWebServer. This returns the inbound SNI names. */

            throw new IOException("DiSNI RDMA write failed", e);
        }
    }

    @Override
    public RdmaNegotiateResponse negotiate(RdmaNegotiateRequest request) throws IOException {
        // Simulate successful negotiation for skeleton implementation
        RdmaNegotiateResponse response = new RdmaNegotiateResponse();
        response.setStatus(0); // Success

        assertNotNull(channelManager);
        assertNotNull(channelManager.getChannels());
        // Note: isUseMultiChannel() checks if actual multi-channel is negotiated with server
        // In mock environment, this will be false until we mock successful negotiation

        // Verify load balancer is initialized
        assertNotNull(channelManager.getLoadBalancer());
    }

    @Test

    void testConstructor() {
        // Verify all fields are properly initialized
        assertNotNull(negotiation);
        assertSame(mockRequest, negotiation.getRequest());
        assertSame(mockResponse, negotiation.getResponse());
        assertSame(testRequestBuffer, negotiation.getRequestRaw());
        assertSame(testResponseBuffer, negotiation.getResponseRaw());
    }

    @Test
    @DisplayName("Constructor with null request should work")

package jcifs.internal.smb2.nego;

import jcifs.Configuration;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Encryption Negotiate Context.
 *
 * This negotiate context is used in SMB 3.x to negotiate
 * encryption capabilities and cipher suites.
 *
 * @author mbechler
 */
public class EncryptionNegotiateContext implements NegotiateContextRequest, NegotiateContextResponse {

 */
package jcifs.internal;

/**
 * Container class for SMB protocol negotiation state.
 * Holds the negotiation request, response, and raw buffer data exchanged
 * between client and server during SMB protocol version negotiation.
 *
 * @author mbechler
 */
public final class SmbNegotiation {

    private final SmbNegotiationRequest request;

    @Mock
    private Response response;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    @DisplayName("Test isValid returns true for valid negotiation")
    void testIsValidReturnsTrue() {
        // Arrange
        when(negotiationResponse.isValid(cifsContext, negotiationRequest)).thenReturn(true);

        // Act