int offset = threadIndex * 10;
                    smbComTreeDisconnect.writeParameterWordsWireFormat(buffer, offset);
                    smbComTreeDisconnect.writeBytesWireFormat(buffer, offset);
                    smbComTreeDisconnect.readParameterWordsWireFormat(buffer, offset);
                    smbComTreeDisconnect.readBytesWireFormat(buffer, offset);
                    smbComTreeDisconnect.toString();

            largeData[i] = (byte) i;
        }

        // Test with different offsets
        int[] offsets = { 0, 10, 50, 90 };

        for (int offset : offsets) {
            // Act
            signingDigest.sign(largeData, offset, 10, request, response);

            // Assert
            verify(signingDigest).sign(largeData, offset, 10, request, response);
        }

        }
    }

    @Test
    @DisplayName("Should write bytes at different buffer offsets")
    void testWriteBytesAtDifferentOffsets() throws Exception {
        // Test at different offsets
        int[] offsets = { 0, 10, 50, 100, 200 };

        for (int offset : offsets) {
            // Given
            byte[] buffer = new byte[1024];
            Smb2SessionSetupRequest req =

        });
    }

    @Test
    @DisplayName("Should write consistent structure at different offsets")
    void testWriteBytesAtDifferentOffsets() throws Exception {
        // Test at different offsets
        int[] offsets = { 0, 10, 50, 100, 200 };

        for (int offset : offsets) {
            // Given
            byte[] buffer = new byte[1024];

        // Verify
        assertEquals(14 + nameBytes.length, bytesEncoded);

        // Check timeout value at offset
        assertEquals(timeout, SMBUtil.readInt8(buffer, offset));

        // Check name length at offset
        assertEquals(nameBytes.length, SMBUtil.readInt4(buffer, offset + 8));

        // Check timeout specified flag at offset
        assertEquals(0x1, buffer[offset + 12]);

        // Test reading data from different buffer offsets
        byte[] testData = "Test data with offset".getBytes();
        byte[] buffer = new byte[200];
        int offset = 50;
        System.arraycopy(testData, 0, buffer, offset, testData.length);

        int result = response.readDataWireFormat(buffer, offset, testData.length);

        assertEquals(testData.length, result);

    @ParameterizedTest
    @ValueSource(ints = { 0, 10, 50, 100, 200 })
    void testReadBytesWireFormatAtDifferentOffsets(int offset) throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[256];

        // Write valid structure at offset
        SMBUtil.writeInt2(4, buffer, offset);
        SMBUtil.writeInt2(0, buffer, offset + 2);

        // When

        // No group (offset 0)
        for (int i = 8; i < 12; i++)
            securityDescriptorBytes[i] = 0;
        // No SACL (offset 0)
        for (int i = 12; i < 16; i++)
            securityDescriptorBytes[i] = 0;
        // DACL at offset 20
        securityDescriptorBytes[16] = 20;
        securityDescriptorBytes[17] = 0;
        securityDescriptorBytes[18] = 0;
        securityDescriptorBytes[19] = 0;

        }
    }

    @BeforeEach
    void setUp() {
        smbComNtTransaction = new ConcreteSmbComNtTransaction();
    }

    @Test
    void testConstructor() {
        // Test if the offsets are initialized correctly by the constructor.
        assertEquals(69, smbComNtTransaction.primarySetupOffset, "primarySetupOffset should be initialized to 69");

     */
    public LockingAndXRange(final boolean largeFile) {
        this.largeFile = largeFile;
    }

    /**
     * Returns the process ID associated with this lock range.
     *
     * @return the process ID
     */
    public int getPid() {
        return this.pid;
    }

    /**
     * Returns the starting byte offset of the lock range.
     *