}
        this.digest.update(input, offset, len);
        this.updates++;
    }

    /**
     * Finalize and return the calculated message digest
     *
     * @return calculated digest
     */
    public byte[] digest() {
        byte[] b = this.digest.digest();

        if (log.isTraceEnabled()) {
            log.trace("digest: ");

                        }

                        uid = response.uid;

                        if (request.digest != null) {
                            /* success - install the signing digest */
                            transport.digest = request.digest;
                        }

                        connectionState = 2;

                        state = 0;

        assertDoesNotThrow(() -> digest.update(data, 0, 0));
    }

    @Test
    @DisplayName("Test digest method")
    void testDigest() {
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey);
        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        digest.update(data, 0, data.length);

        byte[] result = digest.digest();
        assertNotNull(result);

        mac.update(seqBytes); // sequence
        mac.update(data); // data
        final byte[] dgst = mac.digest();
        byte[] trunc = new byte[8];
        System.arraycopy(dgst, 0, trunc, 0, 8);

        if (log.isDebugEnabled()) {
            log.debug("Digest " + Hexdump.toHexString(dgst));
            log.debug("Truncated " + Hexdump.toHexString(trunc));
        }

            Arrays.fill(sessionKey, (byte) 0xEE);

            Smb2SigningDigest digest = new Smb2SigningDigest(sessionKey, Smb2Constants.SMB2_DIALECT_0202, null);

            // Close multiple times should not throw
            digest.close();
            digest.close();
            digest.secureWipeKey();
            digest.close();

            // Operations should still fail
            byte[] data = new byte[128];

        // Given
        doNothing().when(messageBlock).setDigest(digest);
        when(messageBlock.getDigest()).thenReturn(digest);

        // When
        messageBlock.setDigest(digest);
        SMBSigningDigest retrievedDigest = messageBlock.getDigest();

        // Then
        assertEquals(digest, retrievedDigest);
        verify(messageBlock).setDigest(digest);
        verify(messageBlock).getDigest();
    }

    @Test

            return 0;
        }

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

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

        @Override
        public void setResponse(CommonServerMessageBlockResponse msg) {

    }

    /**
     * @return the digest
     */
    @Override
    public final SMB1SigningDigest getDigest() {
        return this.digest;
    }

    /**
     * @param digest
     *            the digest to set
     */
    @Override
    public final void setDigest(final SMBSigningDigest digest) {
        this.digest = (SMB1SigningDigest) digest;
    }

    /**

        assertEquals(expectedEncodeLength, response.encode(dst, dstIndex));

        // Test digest methods
        doNothing().when(response).setDigest(digest);
        when(response.getDigest()).thenReturn(digest);
        response.setDigest(digest);
        assertEquals(digest, response.getDigest());

        // Test mid methods
        long mid = 123456L;

                final HMACT64 userKey = new HMACT64(ntlmv2Hash);
                userKey.update(hmac.digest());
                userKey.digest(dest, offset, 16);
                break;
            default:
                md4.update(md4.digest());
                md4.digest(dest, offset, 16);
                break;
            }
        } catch (final Exception e) {
            throw new SmbException("", e);