}

    /**
     * Creates a digest (abbreviated summary) of document content.
     * Truncates and normalizes content to create a summary suitable for display.
     *
     * @param responseData the response data from crawling (not currently used)
     * @param content the content to create a digest from
     * @param dataMap additional data map (not currently used)

        }
    }

    @Nested
    @DisplayName("Signature Verification Tests")
    class SignatureVerificationTests {

        @Test
        @DisplayName("Should verify signature when digest is present and successful")
        void testVerifySignatureSuccess() throws Exception {
            byte[] buffer = new byte[1024];
            echoResponse.setDigest(mockDigest);

      throws NoSuchAlgorithmException {
    MessageDigest digest = MessageDigest.getInstance(algorithmName);
    assertEquals(
        HashCode.fromBytes(digest.digest(input)), ALGORITHMS.get(algorithmName).hashBytes(input));
    for (int bytes = 4; bytes <= digest.getDigestLength(); bytes++) {
      assertEquals(
          HashCode.fromBytes(Arrays.copyOf(digest.digest(input), bytes)),

        byte[] digest = md.digest();

        String md5path = repository.pathOf(artifact) + ".md5";
        File md5artifactFile = new File(repository.getBasedir(), md5path);
        try (Writer writer =
                new OutputStreamWriter(new FileOutputStream(md5artifactFile), StandardCharsets.ISO_8859_1)) {
            writer.append(printHexBinary(digest));
        }
    }

        hmac.update(Strings.getUNIBytes(user.toUpperCase()));
        hmac.update(Strings.getUNIBytes(domain.toUpperCase()));
        hmac = Crypto.getHMACT64(hmac.digest());
        hmac.update(challenge);
        hmac.update(clientChallenge);
        hmac.digest(response, 0, 16);
        System.arraycopy(clientChallenge, 0, response, 16, 8);
        return response;
    }

    /**

        request.flags2 |= flags2;
        request.useUnicode = useUnicode;
        request.response = response; /* needed by sign */
        if (request.digest == null) {
            request.digest = digest; /* for sign called in encode */
        }

        try {
            if (response == null) {
                doSend0(request);
                return;
            }

            // Mock implementation
            return 0;
        }

        @Override
        public void setDigest(SMBSigningDigest digest) {
            this.digest = digest;
        }

        @Override
        public SMBSigningDigest getDigest() {
            return this.digest;
        }

        @Override
        public CommonServerMessageBlockResponse getResponse() {
            return this.response;

            }

            // SMB 3.1.1 spec: Hash = Hash(PreviousHash || Message)
            digest.update(previousHash);
            digest.update(messageData);

            return digest.digest();
        } catch (NoSuchAlgorithmException e) {
            throw new CIFSException("Hash algorithm not available: " + hashAlgorithm, e);
        }
    }

    /**
     * Gets the name of a hash algorithm.
     *

    public Smb2SigningDigest getDigest() {
        return this.digest;
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlock#setDigest(jcifs.internal.SMBSigningDigest)
     */
    @Override
    public void setDigest(final SMBSigningDigest digest) {
        this.digest = (Smb2SigningDigest) digest;
        if (this.next != null) {

            assertTrue(testMessage.isResponse());
        }
    }

    @Nested
    @DisplayName("Digest Tests")
    class DigestTests {

        @Test
        @DisplayName("Should get and set digest")
        void testDigestProperty() {
            assertNull(testMessage.getDigest());
            testMessage.setDigest(mockDigest);