byte[] buffer = new byte[100];

            assertTrue(testBlock.verifySignature(buffer, 0, 100));
            verify(mockDigest, never()).verify(any(), anyInt(), anyInt(), anyInt(), any());
        }

        @Test
        @DisplayName("Test verify signature success")
        void testVerifySignatureSuccess() {
            testBlock.setDigest(mockDigest);
            testBlock.setErrorCode(0);

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

        assertEquals(mockNotifyInfo2, notifications.get(1));

        // Verify first notification
        FileNotifyInformation info1 = notifications.get(0);
        assertEquals(FileNotifyInformation.FILE_ACTION_ADDED, info1.getAction());
        assertEquals("test1.txt", info1.getFileName());

        // Verify second notification
        FileNotifyInformation info2 = notifications.get(1);

            // Verify file ID
            byte[] actualFileId = new byte[16];
            System.arraycopy(buffer, 80, actualFileId, 0, 16);
            assertArrayEquals(testFileId, actualFileId);

            // Verify that info.encode was called
            verify(mockInfo, times(1)).encode(any(byte[].class), anyInt());

            // Verify total bytes written

        // Verify
        assertNull(result, "Authentication result should be null");
        verify(mockResponse).setHeader("WWW-Authenticate", "NTLM");
        verify(mockResponse).setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        verify(mockResponse).setContentLength(0);
        verify(mockResponse).flushBuffer();
    }

    /**

 */
class ResolverTypeTest {

    /**
     * Tests that all expected enum constants exist.
     */
    @Test
    void testEnumConstants() {
        // Verify that each enum constant exists and can be referenced
        assertNotNull(ResolverType.RESOLVER_WINS, "RESOLVER_WINS should not be null.");
        assertNotNull(ResolverType.RESOLVER_BCAST, "RESOLVER_BCAST should not be null.");

            message.encode(mockBuffer);

            // Verify key operations happened
            verify(mockBuffer).enc_ndr_small(5); // RPC version
            verify(mockBuffer).enc_ndr_long(0x00000010); // Little-endian / ASCII / IEEE
            verify(mockBuffer).enc_ndr_long(message.call_id);
            verify(mockBuffer).enc_ndr_short(message.getOpnum()); // opnum

        assertNotNull(out);
        assertTrue(out.length > 0);

        // Verify interactions: flags and an empty optimistic token are used
        verify(this.mechContext, times(1)).getFlags();
        ArgumentCaptor<byte[]> cap = ArgumentCaptor.forClass(byte[].class);
        verify(this.mechContext, times(1)).initSecContext(cap.capture(), eq(0), eq(0));

        // Verify the bytes written
        assertTrue(bytesWritten > 0);

        // Verify max setup count is written at position 0
        assertEquals(2, dst[0]);

        // Verify reserved bytes
        assertEquals(0, dst[1]);
        assertEquals(0, dst[2]);

        // Verify total parameter count (4 bytes at position 3)

        // execute
        ToolchainPrivate[] toolchains = toolchainManager.getToolchainsForType("basic", session);

        // verify
        verify(logger, never()).error(anyString());
        assertEquals(1, toolchains.length);
    }

    @Test
    void testToolchainsForUnknownType() throws Exception {
        // prepare