// When
            int offset1 = chunk1.encode(buffer, 0);
            int offset2 = chunk2.encode(buffer, offset1);
            int offset3 = chunk3.encode(buffer, offset1 + offset2);

            // Then
            assertEquals(EXPECTED_SIZE, offset1);
            assertEquals(EXPECTED_SIZE, offset2);
            assertEquals(EXPECTED_SIZE, offset3);

            // Verify first chunk

                    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);
        }

    @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

        // 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
    @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];

            assertEquals(descrBytes[i], dst[offset + i]);
        }
        offset += descrBytes.length;

        // 3. Level (2 bytes)
        assertEquals(0x0001, SMBUtil.readInt2(dst, offset));
        offset += 2;

        // 4. MaxDataCount (2 bytes)
        int maxDataCount = SMBUtil.readInt2(dst, offset);
        assertTrue(maxDataCount > 0);
        offset += 2;

        // Verify total bytes written

        buffer[offset + 3] = 0;
        SMBUtil.writeInt4(0x1234, buffer, offset + 4);
        SMBUtil.writeInt4(0x5678, buffer, offset + 8);
        SMBUtil.writeInt4(0x9ABC, buffer, offset + 12);

        // When
        int bytesRead = response.readBytesWireFormat(buffer, offset);

        // Then
        assertEquals(16, bytesRead);
        assertEquals((byte) 0x02, response.getShareType());

	}

	// To generate random offset/length.
	r := rand.New(rand.NewSource(UTCNow().UnixNano()))

	buf := &bytes.Buffer{}

	// Verify erasure.Decode() for random offsets and lengths.
	for range iterations {
		offset := r.Int63n(length)
		readLen := r.Int63n(length - offset)

		expected := data[offset : offset+readLen]

		// Get the checksums of the current part.