// Verify lengths
        assertEquals(2, setupWritten);
        assertEquals(2, paramWritten);
        assertEquals(0, dataWritten);

        // Verify setup content
        assertEquals(SmbComTransaction.TRANS2_QUERY_FS_INFORMATION, setupBuffer[0]);
        assertEquals(0x00, setupBuffer[1]);

        // Verify parameter content (FS_SIZE_INFO -> 0x0103)

            int dataLength = 200;
            contextResponse.decode(dataBuffer, dataOffset, dataLength);

            // Verify
            assertArrayEquals(nameBytes, contextResponse.getName());
            assertEquals(dataLength, contextResponse.getData().length);

            // Verify data content
            for (int i = 0; i < dataLength; i++) {

        when(mockPrincipal.getName()).thenReturn(expectedUserName);

        // Act: Call the method under test
        String actualUserName = ntlmRequest.getRemoteUser();

        // Assert: Verify that the returned user name is the expected one
        assertEquals(expectedUserName, actualUserName, "getRemoteUser should return the principal's name.");
    }

    /**

        // Act: invoke renew()
        CredentialsInternal result = renewable.renew();

        // Assert: verify interaction and returned value
        verify(renewable, times(1)).renew();
        assertSame(returned, result, "renew() should return the stubbed value");

        // Negative interaction check: no further interactions with the mock
        verifyNoMoreInteractions(renewable);
    }

            int bytesWritten = req.writeBytesWireFormat(buffer, 0);

            // Verify structure
            assertEquals(48, SMBUtil.readInt2(buffer, 0)); // Structure size
            assertEquals(1, SMBUtil.readInt2(buffer, 2)); // Lock count

            // Verify lock sequence (bits 4-7 are sequence number, bits 0-27 are index)
            int lockSequence = SMBUtil.readInt4(buffer, 4);

import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

import org.junit.jupiter.api.BeforeEach;

        ScheduledJobException exception = new ScheduledJobException("Serialization test");

        // Verify that the exception has serialVersionUID field (won't compile if not present)
        assertTrue(exception instanceof java.io.Serializable);
    }

    public void test_longMessage() {
        // Test with very long message
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 1000; i++) {

        // when proper conditions are not met.

        Map<String, Object> docMap = new HashMap<>();

        // This will return false because getFessConfig() will fail
        // We verify the method handles the case gracefully
        try {
            emptyGenerator.isTarget(docMap);
        } catch (IllegalStateException e) {
            // Expected when container is not initialized

            // Read the buffer
            int bytesRead = notification.readBytesWireFormat(buffer, 0);

            // Verify the bytes read
            assertEquals(24, bytesRead);

            // Verify the fields were set correctly using reflection
            Field oplockLevelField = Smb2OplockBreakNotification.class.getDeclaredField("oplockLevel");

        assertTrue(region.hasAccess(RdmaAccess.LOCAL_READ), "Should have local read access");
        assertTrue(region.hasAccess(RdmaAccess.REMOTE_READ), "Should have remote read access");

        // Verify provider was called
        verify(mockProvider, atLeastOnce()).registerMemory(any(ByteBuffer.class), any());
    }

    @Test
    public void testReleaseSendRegion() throws Exception {