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

        }
    }

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

        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;
    }

    /**

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

            }

            // 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.
     *

            // 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;

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

 */
public interface SMBSigningDigest {

    /**
     * Performs MAC signing of the SMB. This is done as follows.
     * The signature field of the SMB is overwritten with the sequence number;
     * The MD5 digest of the MAC signing key + the entire SMB is taken;
     * The first 8 bytes of this are placed in the signature field.
     *
     * @param data
     *            The data.
     * @param offset

        SMBUtil.writeInt2(this.fid, dst, dstIndex);
        dstIndex += 2;
        if (this.digest != null) {
            SMB1SigningDigest.writeUTime(getConfig(), this.lastWriteTime, dst, dstIndex);
        } else {
            log.trace("SmbComClose without a digest");
        }
        return 6;
    }

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