void testNTOWFv1() {
        byte[] hash = NtlmPasswordAuthentication.nTOWFv1("password");
        assertNotNull(hash);
        assertEquals(16, hash.length);
    }

    // Test nTOWFv2
    @Test
    void testNTOWFv2() {
        byte[] hash = NtlmPasswordAuthentication.nTOWFv2("DOMAIN", "user", "password");
        assertNotNull(hash);
        assertEquals(16, hash.length);
    }

    // Test unescape method

    }

    /**
     * Get channel binding hash
     *
     * @return binding hash bytes
     */
    public byte[] getBindingHash() {
        return bindingHash;
    }

    /**
     * Set channel binding hash
     *
     * @param bindingHash binding hash bytes
     */
    public void setBindingHash(byte[] bindingHash) {

    @DisplayName("Should calculate MD4 hash correctly")
    void testMD4Hash() {
        // Given
        String input = "Hello World";
        byte[] data = input.getBytes();

        // When
        MessageDigest md4 = Crypto.getMD4();
        byte[] hash = md4.digest(data);

        // Then
        assertNotNull(hash);
        assertEquals(16, hash.length); // MD4 produces 128-bit hash
    }

    @Test

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

        // Validation should pass with correct hash
        assertTrue(preauthService.validatePreauthIntegrity(sessionId, expectedHash));

        // Validation should fail with incorrect hash
        byte[] incorrectHash = new byte[expectedHash.length];
        secureRandom.nextBytes(incorrectHash);

    }

    /**
     * Generate the ANSI DES hash for the password associated with these credentials.
     *
     * @param password the password to hash
     * @param challenge the server challenge bytes
     * @return the ANSI DES hash response
     */
    static public byte[] getPreNTLMResponse(final String password, final byte[] challenge) {

     */
    @Size(max = 10000)
    @Required
    public String rt;

    /**
     * Hash value for security or validation purposes.
     * This field is optional and used for request verification.
     */
    public String hash;

    /**
     * Query identifier associated with the search that led to this document access.
     * This is required for tracking and analytics purposes.

            Arrays.sort(newInputs);
        }
    }

    /**
     * Calculates the hash code for this CharMappingItem based on inputs and output.
     *
     * @return the hash code value for this object
     */
    @Override
    public int hashCode() {
        return Objects.hash(Arrays.hashCode(inputs), output);
    }

    /**

            byte[] hash = md.digest(input);
            System.arraycopy(hash, 0, derived, 0, Math.min(length, hash.length));

            // If we need more bytes, hash again with counter
            int counter = 1;
            while (derived.length > hash.length * counter) {
                md.update(input);
                md.update((byte) counter);
                hash = md.digest();

     */
    public void setWeight(float weight) {
        this.weight = weight;
    }

    /**
     * Returns the hash code for this RequestData.
     * @return the hash code
     */
    @Override
    public int hashCode() {
        return Objects.hash(method, url, weight);
    }

    /**
     * Checks if this RequestData is equal to another object.

            assertEquals(context.size(), encodedSize);
            assertEquals(1, buffer[0]); // hash algo count (little endian)
            assertEquals(0, buffer[1]);
            assertEquals(8, buffer[2]); // salt length (little endian)
            assertEquals(0, buffer[3]);
            assertEquals(1, buffer[4]); // SHA512 hash algo (little endian)
            assertEquals(0, buffer[5]);