@Test
        @DisplayName("Should handle offset correctly in verify")
        void testVerifyWithOffset() throws Exception {
            byte[] largeData = new byte[256];
            int offset = 64;
            Arrays.fill(largeData, (byte) 0x00);

            // Set signed flag at correct offset
            SMBUtil.writeInt4(ServerMessageBlock2.SMB2_FLAGS_SIGNED, largeData, offset + 16);

            // Create valid signature

// timeZone returns a *time.Location based on the provided offset.
// If the offset is non-sensible, then this uses an offset of zero.
func timeZone(offset time.Duration) *time.Location {
	const (
		minOffset   = -12 * time.Hour  // E.g., Baker island at -12:00
		maxOffset   = +14 * time.Hour  // E.g., Line island at +14:00
		offsetAlias = 15 * time.Minute // E.g., Nepal at +5:45
	)
	offset = offset.Round(offsetAlias)

        @Test
        @DisplayName("Should decode at different buffer offset")
        void testDecodeWithOffset() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[256];
            int offset = 100;
            byte[] responseData = createValidCopyChunkResponse(10, 131072, 1310720);
            System.arraycopy(responseData, 0, buffer, offset, responseData.length);

        final int ownerUOffset = ServerMessageBlock.readInt4(buffer, bufferIndex); // offset to owner sid
        bufferIndex += 4;
        final int ownerGOffset = ServerMessageBlock.readInt4(buffer, bufferIndex); // offset to group sid
        bufferIndex += 4;
        final int saclOffset = ServerMessageBlock.readInt4(buffer, bufferIndex); // offset to sacl
        bufferIndex += 4;

}

func (d *Decoder) emitAny() (any, error) {
	if d.pos >= atomic.LoadInt64(&d.end) {
		return nil, d.mkError(ErrUnexpectedEOF)
	}
	offset := d.pos - 1
	i, t, err := d.any()
	if d.willEmit() {
		d.metaCh <- &MetaValue{
			Offset:    int(offset),
			Length:    int(d.pos - offset),
			Depth:     d.depth,
			Value:     i,
			ValueType: t,
		}
	}
	return i, err
}

     * @param offset
     *            The starting offset in the input data
     * @param len
     *            The length of data to process
     */
    public void update(final byte[] input, final int offset, final int len) {
        if (log.isTraceEnabled()) {
            log.trace("update: " + this.updates + " " + offset + ":" + len);

        assertEquals(expectedBytesWritten, bytesWritten);

        // Verify structure
        assertEquals(25, SMBUtil.readInt2(buffer, offset)); // Structure size
        assertEquals(TEST_SECURITY_MODE, buffer[offset + 3] & 0xFF); // Security mode
        assertEquals(TEST_CAPABILITIES, SMBUtil.readInt4(buffer, offset + 4)); // Capabilities
    }

    @Test
    @DisplayName("Should handle session binding scenarios")

    }

    // Helper method to extract string from buffer
    private String extractStringFromBuffer(byte[] buffer, int offset, int maxLen) {
        int end = offset;
        while (end < offset + maxLen && buffer[end] != 0) {
            end++;
        }
        return new String(buffer, offset, end - offset, StandardCharsets.UTF_8);
    }

//
//	var spd sparseDatas = []sparseEntry{
//		{Offset: 2,  Length: 5},  // Data fragment for 2..6
//		{Offset: 18, Length: 3},  // Data fragment for 18..20
//	}
//	var sph sparseHoles = []sparseEntry{
//		{Offset: 0,  Length: 2},  // Hole fragment for 0..1
//		{Offset: 7,  Length: 11}, // Hole fragment for 7..17
//		{Offset: 21, Length: 4},  // Hole fragment for 21..24
//	}
//

    /** The buffer of bytes sent to the stream */
    private byte[] buffer = new byte[DEFAULT_BUFFER_LENGTH];

    /** Offset of the start of unwritten data in the buffer */
    private int start = 0;

    /** Offset of the end (semi-open) of unwritten data in the buffer */
    private int end = 0;

    @Override
    public void write(final int b) throws IOException {