@Test
    @DisplayName("reauthenticate throws CIFSException when underlying call fails")
    void reauthenticate_throws() throws CIFSException {
        doThrow(new CIFSException("reauth failed")).when(session).reauthenticate();
        CIFSException ex = assertThrows(CIFSException.class, () -> session.reauthenticate());
        assertTrue(ex.getMessage().contains("failed"));

                    request.setDigest(getDigest());
                }

                if (request instanceof RequestWithPath rpath) {
                    ((RequestWithPath) request).setFullUNCPath(getTargetDomain(), getTargetHost(), rpath.getFullUNCPath());
                }

                try {
                    if (log.isTraceEnabled()) {
                        log.trace("Request " + request);

    }

    @Test
    @DisplayName("Should derive unique keys for different preauth values")
    void testDeriveKeys_UniquePreauthValues() {
        // Given
        byte[] preauth1 = new byte[64];
        byte[] preauth2 = new byte[64];
        new SecureRandom().nextBytes(preauth1);
        new SecureRandom().nextBytes(preauth2);
        int dialect = Smb2Constants.SMB2_DIALECT_0311;

        // When

            if (enforceIntegrity) {
                throw new CIFSException("No preauth integrity context found for session: " + sessionId);
            }
            log.warn("No preauth integrity context for session {}, skipping update", sessionId);
            return;
        }

        if (!context.isValid()) {
            throw new CIFSException("Preauth integrity context is invalid for session: " + sessionId);
        }

    private int[] hashAlgos;
    private byte[] salt;

    /**
     * Constructs a preauth integrity negotiate context with the specified parameters.
     *
     * @param config the SMB configuration
     * @param hashAlgos the supported hash algorithms
     * @param salt the salt value for preauth integrity
     */

        void testDifferentContextTypes() {
            PreauthIntegrityNegotiateContext preauth = new PreauthIntegrityNegotiateContext();
            EncryptionNegotiateContext encryption = new EncryptionNegotiateContext();

            assertNotEquals(preauth.getContextType(), encryption.getContextType());
            assertEquals(0x1, preauth.getContextType());
            assertEquals(0x2, encryption.getContextType());
        }

        assertNotNull(enc);
        assertTrue(enc instanceof EncryptionNegotiateContext);

        // Test preauth context
        NegotiateContextResponse preauth = Smb2NegotiateResponse.createContext(PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE);
        assertNotNull(preauth);
        assertTrue(preauth instanceof PreauthIntegrityNegotiateContext);

        // Test unknown context

          MYSQL_RANDOM_ROOT_PASSWORD: "yes"
        ports:
          - 9910:3306
        options: >-
          --health-cmd "mysqladmin ping -ugorm -pgorm"
          --health-interval 10s
          --health-start-period 10s
          --health-timeout 5s
          --health-retries 10

    steps:
    - name: Set up Go 1.x
      uses: actions/setup-go@v5
      with:
        go-version: ${{ matrix.go }}

        return 4;
    }

    @SuppressWarnings("deprecation")
    private static boolean isExternalAuth(final NtlmPasswordAuthenticator pwAuth) {
        return pwAuth instanceof jcifs.smb.NtlmPasswordAuthentication
                && !((jcifs.smb.NtlmPasswordAuthentication) pwAuth).areHashesExternal() && pwAuth.getPassword().isEmpty();
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {

    }

    @AfterEach
    public void tearDown() {
        if (preauthService != null) {
            preauthService.cleanup();
        }
    }

    @Test
    @DisplayName("Test preauth salt generation")
    public void testPreauthSaltGeneration() {
        byte[] salt1 = preauthService.generatePreauthSalt();
        byte[] salt2 = preauthService.generatePreauthSalt();

        assertNotNull(salt1);