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

        int offset = 0;
        int size = 3;

        // Simulate successful verification
        when(mockResponse.verifySignature(buffer, offset, size)).thenReturn(true);
        assertTrue(mockResponse.verifySignature(buffer, offset, size));

        // Simulate failed verification
        when(mockResponse.verifySignature(buffer, offset, size)).thenReturn(false);

        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;

     * @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);

}

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
}

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

    /** 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 {

     * Verifies that the method returns the correct time zone offset.
     * @throws CIFSException
     */
    @Test
    void testGetServerTimeZoneOffset() throws CIFSException {
        when(smbTreeHandle.getServerTimeZoneOffset()).thenReturn(0L);
        assertEquals(0L, smbTreeHandle.getServerTimeZoneOffset(), "Server time zone offset should be 0");
        when(smbTreeHandle.getServerTimeZoneOffset()).thenReturn(3600000L);