DummyPlainSMB next = new DummyPlainSMB();
        DummyAndXBlock block = new DummyAndXBlock(next);
        block.customBatchLimit = 2; // batchLevel (0) < limit (2) so chaining allowed
        block.uid = 0x1234;
        block.useUnicode = true;

        byte[] buf = new byte[256];
        int n = block.writeAndXWireFormat(buf, 0);

        assertTrue(n > 0);

        when(resp.getErrorCode()).thenReturn(0);
        when(resp.getNotifyInformation()).thenReturn(info);
        setupSmb2(resp, new byte[16]);
        SmbWatchHandleImpl sut = new SmbWatchHandleImpl(handle, 0x1234, true);

        List<FileNotifyInformation> result = sut.watch();

        assertSame(info, result, "Should return response notify information");

        RdmaProvider provider = RdmaProviderFactory.selectBestProvider();

        // Use localhost for testing - should work with TCP fallback
        InetSocketAddress address = new InetSocketAddress("localhost", 12345);

        try (RdmaConnection connection = provider.createConnection(address, null)) {
            assertNotNull(connection, "Connection should not be null");

        SpnegoContext ctx = newContext();

        // The initial token path should ask the mechanism for a zero-length optimistic token
        when(this.mechContext.getFlags()).thenReturn(0x1234);
        when(this.mechContext.initSecContext(any(byte[].class), eq(0), eq(0))).thenReturn(new byte[] { 0x01, 0x02 });

        // Act: len==0 triggers initial token construction

        @ValueSource(ints = { 0, 1, 10, 50, 70 })
        void testEncodeAtDifferentPositions(int position) {
            // Given
            byte[] largeBuffer = new byte[200];
            long sourceOffset = 12345L;
            long targetOffset = 67890L;
            int length = 99999;
            SrvCopychunk chunk = new SrvCopychunk(sourceOffset, targetOffset, length);

            // When

    }

    @Test
    @DisplayName("Should handle parsing invalid message bytes")
    void testInvalidMessageBytes() {
        // Given
        byte[] invalidBytes = { 1, 2, 3, 4, 5 }; // Too short and invalid

        // When/Then
        assertThrows(IOException.class, () -> {
            new Type3Message(invalidBytes);
        });
    }

    @Test

    }

    @Test
    @DisplayName("Should get challenge from server")
    void testGetChallenge() throws Exception {
        // Given: Mock transport with server key
        byte[] expectedKey = { 1, 2, 3, 4 };

        SmbTransportPoolImpl poolSpy = spy(pool);
        when(ctx.getTransportPool()).thenReturn(poolSpy);

        SmbTransportImpl mockTransport = mock(SmbTransportImpl.class);

class Trans2FindNext2Test {

    private Trans2FindNext2 trans2FindNext2;
    private Configuration config;

    @Mock
    private Configuration mockConfig;

    private static final int TEST_SID = 0x1234;
    private static final int TEST_RESUME_KEY = 0xABCD;
    private static final String TEST_FILENAME = "testfile.txt";
    private static final int TEST_BATCH_COUNT = 100;
    private static final int TEST_BATCH_SIZE = 8192;

        assertTrue(noKey.getMessage().contains("No session key"));

        // Set a key via reflection and verify retrieval
        byte[] key = new byte[] { 1, 2, 3, 4 };
        setField(session, "sessionKey", key);
        assertArrayEquals(key, session.getSessionKey());
    }

    @Test
    @DisplayName("getSmbTree returns same instance for same share/service")

    @Mock
    private InetAddress localAddr;

    private static final int DEFAULT_PORT = 445;
    private static final String TEST_HOST = "test.server.com";
    private static final int LOCAL_PORT = 12345;

    @BeforeEach
    void setUp() {
        // Common setup for all tests
    }

    @Nested
    @DisplayName("GetSmbTransport Methods")
    class GetSmbTransportTests {

        @Test