@Test
    @DisplayName("Test Response interface methods - verifySignature")
    void testVerifySignature() {
        // Given
        byte[] buffer = new byte[256];
        int offset = 10;
        int size = 100;
        when(response.verifySignature(buffer, offset, size)).thenReturn(true);

        // When
        boolean verified = response.verifySignature(buffer, offset, size);

        // Then

            assertTrue(testBlock.verifySignature(buffer, 0, 100));
        }

        @Test
        @DisplayName("Test verify signature with error code")
        void testVerifySignatureWithErrorCode() {
            testBlock.setDigest(mockDigest);
            testBlock.setErrorCode(1);
            byte[] buffer = new byte[100];

            assertTrue(testBlock.verifySignature(buffer, 0, 100));

            byte[] buffer = new byte[100];
            response.setDigest(mockDigest);
            when(mockDigest.verify(buffer, 0, 100, 0, response)).thenReturn(false);

            boolean result = response.verifySignature(buffer, 0, 100);

            assertTrue(result);
            assertFalse(response.isVerifyFailed());
        }

        @Test
        @DisplayName("Should handle signature verification failure")

            when(mockConfig.isRequireSecureNegotiate()).thenReturn(true);
            when(mockDigest.verify(buffer, 0, 100, 0, echoResponse)).thenReturn(false);

            boolean result = echoResponse.verifySignature(buffer, 0, 100);

            assertTrue(result);
            assertFalse(echoResponse.isVerifyFailed());
            verify(mockDigest).verify(buffer, 0, 100, 0, echoResponse);
        }

        @Test

        this.uid = 0;
        this.tid = 0xFFFF;
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#verifySignature(byte[], int, int)
     */
    @Override
    public boolean verifySignature(final byte[] buffer, final int i, final int size) {
        /*
         * Verification fails (w/ W2K3 server at least) if status is not 0. This

        }

        @Override
        public void setRawPayload(byte[] payload) {
            this.rawPayload = payload;
        }

        @Override
        public boolean verifySignature(byte[] data, int offset, int length) {
            return true; // Default to successful verification
        }

        public void setRetainPayload(boolean retain) {
            this.retainPayload = retain;

            return 1;
        }

        @Override
        public int getErrorCode() {
            return errorCode;
        }

        @Override
        public boolean verifySignature(byte[] buffer, int i, int size) {
            return true;
        }

        @Override
        public boolean isVerifyFailed() {
            return false;
        }

        @Override

        }

        @Override
        public void setRawPayload(byte[] rawPayload) {
            this.rawPayload = rawPayload;
        }

        @Override
        public boolean verifySignature(byte[] buffer, int i, int size) {
            // Mock implementation
            return true;
        }

        @Override
        public byte[] getRawPayload() {
            return this.rawPayload;

        if (isRetainPayload()) {
            final byte[] payload = new byte[len];
            System.arraycopy(buffer, 4, payload, 0, len);
            setRawPayload(payload);
        }

        if (!verifySignature(buffer, 4, len)) {
            throw new SMBProtocolDecodingException("Signature verification failed for " + this.getClass().getName());
        }
        return len;
    }

    /**