if (bitsField != null && !bitsField.getValues().isEmpty()) {
                                    docMap.put(fessConfig.getQueryCollapseInnerHitsName() + "_hash", bitsField.getValues().get(0));
                                }
                                docMap.put(fessConfig.getQueryCollapseInnerHitsName(), StreamUtil.stream(innerSearchHits.getHits())

        // Verify hash is not null
        byte[] hash = transport.getPreauthIntegrityHash();
        assertNotNull(hash);

        // Verify hash is a copy, not the original
        byte[] hash2 = transport.getPreauthIntegrityHash();
        assertNotSame(hash, hash2);
        assertArrayEquals(hash, hash2);
    }

    /**
     * Test that pre-auth hash is reset on error
     */
    @Test

    }

    /**
     * Gets the selected hash algorithm.
     *
     * @return the hash algorithm
     */
    public int getSelectedHashAlgorithm() {
        return selectedHashAlgorithm;
    }

    /**
     * Calculates hash according to SMB 3.1.1 preauth integrity specification.
     *
     * @param previousHash the previous hash in the chain
     * @param messageData the message data to hash

                }
            }
        }
        return hash;
    }

    /**
     * Encodes a similar document hash using GZIP compression and Base64 encoding.
     * This reduces storage space for hash values while maintaining uniqueness.
     *
     * @param hash the hash string to encode

        buffer = new byte[BUFFER_SIZE];
    }

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

        @Test
        @DisplayName("Should create instance with Configuration, hash algorithms and salt")
        void testConstructorWithConfigHashAlgosAndSalt() {
            int[] hashAlgos = { PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512 };
            byte[] salt = { 0x01, 0x02, 0x03, 0x04 };

        return nTOWFv2(domain, username, getNTHash(password));
    }

    /**
     * Generates the NTOWFv2 hash for the given domain, username, and password hash.
     *
     * @param domain the authentication domain
     * @param username the username
     * @param passwordHash
     *            NT password hash
     *
     * @return the calculated mac
     */

    }

    /**
     * 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) {

        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) {

            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();