@Mock
        CIFSContext mockCtx;

        @Mock
        SidResolver mockResolver;

        @BeforeEach
        void setup() {
            lenient().when(mockCtx.getSIDResolver()).thenReturn(mockResolver);
        }

        @Test
        @DisplayName("Manual resolve calls resolver with this SID")
        void testResolveManual() throws Exception {
            // Arrange

        // Create a mock SmbTransportInternal for RdmaTransport
        SmbTransportInternal mockTransport = mock(SmbTransportInternal.class);
        when(mockTransport.isDisconnected()).thenReturn(true);
        when(mockTransport.toString()).thenReturn("MockTransport");

        try (RdmaTransport transport = new RdmaTransport(mockTransport, testContext)) {
            assertNotNull(transport, "Transport should not be null");

    void testCreateResponse() {
        // Given
        Configuration mockConfig = mock(Configuration.class);
        CIFSContext mockContext = mock(CIFSContext.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        Smb2TreeDisconnectRequest request = new Smb2TreeDisconnectRequest(mockConfig);

        // When
        Smb2TreeDisconnectResponse response = request.createResponse(mockContext, request);

        void testAllowChain() {
            TestServerMessageBlock2Request nextRequest = new TestServerMessageBlock2Request(mockConfig);
            when(mockConfig.isAllowCompound("TestServerMessageBlock2Request")).thenReturn(true);

            boolean result = testRequest.allowChain(nextRequest);

            assertTrue(result);
            verify(mockConfig, times(2)).isAllowCompound("TestServerMessageBlock2Request");
        }

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
        mockContext = mock(CIFSContext.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        request = new Smb2TreeConnectRequest(mockConfig, TEST_PATH);
    }

    @Test
    @DisplayName("Should create request with correct command type and path")

    @BeforeEach
    void setUp() {
        mockConfig = mock(Configuration.class);
        mockContext = mock(CIFSContext.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        request = new Smb2SessionSetupRequest(mockContext, TEST_SECURITY_MODE, TEST_CAPABILITIES, TEST_PREVIOUS_SESSION_ID, TEST_TOKEN);
    }

    @Test

    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);
        Name mockName = new Name(mockConfig, "TEST", 0x20, null);
        mockQueryAddress.hostName = mockName;

        // Spy to override getPasswordAsCharArray() to return null
        JAASAuthenticator spyAuth = spy(new JAASAuthenticator("DOM", "user", null));
        when(spyAuth.getPasswordAsCharArray()).thenReturn(null);

        PasswordCallback pc = new PasswordCallback("pass:", false);
        spyAuth.handle(new Callback[] { pc });

        // Since getPasswordAsCharArray() returned null, handler should not set a password

    @Test
    void testResolve() throws IOException {
        CIFSContext mockContext = mock(CIFSContext.class);
        SidResolver mockResolver = mock(SidResolver.class);
        when(mockContext.getSIDResolver()).thenReturn(mockResolver);

        SID sid = new SID(adminSidString);
        String server = "myserver";
        sid.resolve(server, mockContext);

    }

    @Test
    @DisplayName("initResponse prepares a response instance")
    void initResponseCreatesResponse() {
        SmbComNTCreateAndX req = createRequest(0, 0);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        SmbComNTCreateAndXResponse resp = req.initResponse(mockContext);
        assertNotNull(resp, "Response should not be null after init");
        // getResponse should now return the same instance