import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.HashMap;

import javax.security.auth.Subject;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.NameCallback;

        // Act
        handle.close();

        // Assert
        // Verify sendrecv was called once for open and once for close
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarOpenPolicy2.class));
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarClose.class));
    }

    @Test

        }

        // Execute and verify
        try {
            processor.process(responseData);
            fail("Should throw ChildUrlsException");
        } catch (ChildUrlsException e) {
            Set<RequestData> childUrls = e.getChildUrlList();
            assertNotNull(childUrls);
            assertEquals(3, childUrls.size());

            // Verify all URLs are present

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;

        filter.doFilter(request, response, filterChain);

        verify(response).setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        verify(response).setHeader("WWW-Authenticate", "NTLM");
        verify(response).addHeader("WWW-Authenticate", "Basic realm=\"TestRealm\"");
        verify(filterChain, never()).doFilter(any(), any());
    }

    @Test

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

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

 */
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.");

        byte[] rawKey = keyManager.getRawKey(sessionId);
        assertNotNull(rawKey, "Should retrieve raw key");
        assertArrayEquals(testKey, rawKey, "Raw key should match");

        // Verify we get a copy, not the original
        rawKey[0] = (byte) ~rawKey[0];
        byte[] rawKey2 = keyManager.getRawKey(sessionId);
        assertArrayEquals(testKey, rawKey2, "Should still match original");
    }

    @Test

            handler.handle(WinError.WINERR_CODES[i], WinError.WINERR_MESSAGES[i]);
        }

        // Verify the collaborator is invoked exactly N times
        verify(handler, times(WinError.WINERR_CODES.length)).handle(anyInt(), anyString());

        // Capture one known interaction to verify argument integrity
        ArgumentCaptor<Integer> codeCap = ArgumentCaptor.forClass(Integer.class);