@Mock
    private NameServiceClient mockNameServiceClient;

    @Mock
    private NetbiosAddress mockLocalHost;

    @BeforeEach
    void setUp() {
        // Setup mock context with lenient stubbing to avoid UnnecessaryStubbingException
        lenient().when(mockContext.getConfig()).thenReturn(mockConfig);
        lenient().when(mockContext.getNameServiceClient()).thenReturn(mockNameServiceClient);

            }
        }
    }

    @BeforeEach
    void setup() throws MalformedURLException, CIFSException {
        // Common happy-path defaults
        // Use lenient() to avoid strict stubbing issues with Mockito
        lenient().when(tree.acquire()).thenReturn(tree);
        lenient().when(tree.getConfig()).thenReturn(config);
        lenient().when(config.getListCount()).thenReturn(10);

    @Mock
    private NbtAddress mockQueryAddress;

    private NodeStatusResponse response;

    @BeforeEach
    void setUp() throws Exception {
        // Setup mock configuration with lenient stubbing
        lenient().when(mockConfig.getOemEncoding()).thenReturn("UTF-8");

        // Setup mock query address
        mockQueryAddress = mock(NbtAddress.class);

    void setUp() {
        mockConfig = mock(Configuration.class);
        mockContext = mock(CIFSContext.class);
        testFileId = new byte[16];
        Arrays.fill(testFileId, (byte) 0xAB);

        // Use lenient stubbing for default configuration values
        lenient().when(mockConfig.getNotifyBufferSize()).thenReturn(8192);
        lenient().when(mockContext.getConfig()).thenReturn(mockConfig);

            when(mockCtx.supportsIntegrity()).thenReturn(true);
            when(mockCtx.calculateMIC(any(byte[].class))).thenReturn(new byte[] { 42 });
            // verifyMIC returns void; no stubbing needed
            when(mockCtx.isMICAvailable()).thenReturn(true);

            // Act
            useContext(mockCtx);

            // Assert: verify key interactions and ordering where meaningful

        return Base64.getEncoder().encodeToString(finalMessage);
    }

    @BeforeEach
    public void setUp() throws UnknownHostException {
        ntlmSsp = new NtlmSsp();

        // Use lenient stubbing to avoid UnnecessaryStubbing errors for tests that don't need all mocks
        lenient().when(mockCifsContext.getConfig()).thenReturn(mockConfig);
        lenient().when(mockConfig.getDefaultDomain()).thenReturn("DOMAIN");

    @Mock
    private Configuration mockConfig;

    private NameQueryResponse nameQueryResponse;

    @BeforeEach
    void setUp() {
        // Mock the OEM encoding configuration with lenient stubbing
        // since not all tests need this stub
        lenient().when(mockConfig.getOemEncoding()).thenReturn("UTF-8");

        // Initialize NameQueryResponse before each test

            return super.encodeMessage(msg, out);
        }
    }

    private TestDcerpcHandle handle;

    @BeforeEach
    void setUp() {
        // Setup buffer cache mocks with lenient stubbing
        lenient().when(mockContext.getBufferCache()).thenReturn(mockBufferCache);
        lenient().when(mockBufferCache.getBuffer()).thenReturn(new byte[8192]);
        handle = new TestDcerpcHandle(mockContext, mockBinding);

            message.ptype = DcerpcConstants.RPC_PT_REQUEST;
            message.flags = DcerpcConstants.RPC_C_PF_BROADCAST;
            message.length = 100;
            message.call_id = 5;

            // Use lenient stubbing to avoid UnnecessaryStubbingException
            lenient().doNothing().when(mockBuffer).enc_ndr_small(anyInt());
            lenient().doNothing().when(mockBuffer).enc_ndr_long(anyInt());

            int maxXmit = 1024;
            int maxRecv = 2048;
            when(mockHandle.getMaxXmit()).thenReturn(maxXmit);
            when(mockHandle.getMaxRecv()).thenReturn(maxRecv);

            // Use lenient stubbing to handle multiple calls
            lenient().doNothing().when(mockBuffer).enc_ndr_short(anyInt());
            lenient().doNothing().when(mockBuffer).enc_ndr_long(anyInt());