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 {

  internal const val B0_FLAG_FIN = 128

  /** Byte 0 reserved flag 1. Must be 0 unless negotiated otherwise. */
  internal const val B0_FLAG_RSV1 = 64

  /** Byte 0 reserved flag 2. Must be 0 unless negotiated otherwise. */
  internal const val B0_FLAG_RSV2 = 32

  /** Byte 0 reserved flag 3. Must be 0 unless negotiated otherwise. */
  internal const val B0_FLAG_RSV3 = 16

  /** Byte 0 mask for the frame opcode. */

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.internal;

/**
 * Interface for SMB protocol negotiation request messages.
 * Represents the client's request to negotiate SMB protocol version and capabilities
 * with the server, including security requirements like message signing.
 *
 * @author mbechler
 */
public interface SmbNegotiationRequest {

    /**

        byte[] initialHash = preauthService.getCurrentPreauthHash(sessionId);
        assertNotNull(initialHash);

        // Update with negotiate message
        byte[] negotiateMessage = "SMB2 Negotiate Request".getBytes();
        preauthService.updatePreauthHash(sessionId, negotiateMessage);

        byte[] afterNegotiateHash = preauthService.getCurrentPreauthHash(sessionId);

        // Arrange & Act
        SmbUnsupportedOperationException ex = new SmbUnsupportedOperationException();

        // Assert
        assertEquals("Operation is not supported with the negotiated capabilities", ex.getMessage(),
                "Default message should match the class contract");
        assertNull(ex.getCause(), "No cause expected from default constructor");

        when(transport.isSMB2()).thenReturn(false);
        when(transport.getContext()).thenReturn(context);
        when(session.getTargetHost()).thenReturn("localhost");

        // Mock negotiate response for SMB1
        SmbComNegotiateResponse nego = mock(SmbComNegotiateResponse.class);
        ServerData serverData = new ServerData();
        when(nego.getServerData()).thenReturn(serverData);

        when(negotiateResponse.getSelectedPreauthHash()).thenReturn(1); // SHA-512
        setPrivateField(transport, "smb2", true);
        setPrivateField(transport, "negotiated", negotiateResponse);

        int threadCount = 10;
        CountDownLatch startLatch = new CountDownLatch(1);
        CountDownLatch doneLatch = new CountDownLatch(threadCount);

            this.encryptionKey = encryptionKey.clone();
            this.decryptionKey = decryptionKey.clone();
        }
    }

    /**
     * Get the negotiated cipher identifier
     * @return the negotiated cipher ID
     */
    public int getCipherId() {
        return this.cipherId;
    }

    /**
     * Get the SMB dialect version
     * @return the SMB dialect version

        try {
            resp = send(req, RequestParam.NO_RETRY);
        } catch (final SMBSignatureValidationException e) {
            throw new SMBProtocolDowngradeException("Signature error during negotiate validation", e);
        } catch (final SmbException e) {
            if (log.isDebugEnabled()) {
                log.debug(String.format("VALIDATE_NEGOTIATE_INFO response code 0x%x", e.getNtStatus()));
            }

import jcifs.config.PropertyConfiguration;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.smb2.nego.CompressionNegotiateContext;

/**
 * Comprehensive tests for SMB3 compression negotiate context.
 */
public class CompressionNegotiateContextTest {

    private Configuration config;
    private CompressionNegotiateContext context;

    @BeforeEach
    public void setUp() throws Exception {