// The slice aliases the buffer content at least until the next buffer modification,
// so immediate changes to the slice will affect the result of future reads.
func (b *Buffer) Bytes() []byte { return b.buf[b.off:] }

// AvailableBuffer returns an empty buffer with b.Available() capacity.
// This buffer is intended to be appended to and

            assertNotNull(buffer, "Buffer should not be null even when cache is full");
            assertEquals(SmbComTransaction.TRANSACTION_BUF_SIZE, buffer.length, "Buffer should have correct size");
            buffers.add(buffer);
        }

        // When - Release all buffers back
        for (byte[] buffer : buffers) {
            BufferCache.releaseBuffer(buffer);
        }

        byte[] buffer = new byte[8];

        // Path consumed (2 bytes)
        SMBUtil.writeInt2(0, buffer, 0);

        // Number of referrals (2 bytes) - 0
        SMBUtil.writeInt2(0, buffer, 2);

        // Flags (2 bytes)
        SMBUtil.writeInt2(0, buffer, 4);

        // Padding (2 bytes)
        buffer[6] = 0;
        buffer[7] = 0;

        return buffer;
    }

            byte[] buffer = new byte[64];
            SMBUtil.writeInt2(17, buffer, 0);
            SMBUtil.writeInt2(0, buffer, 2);
            SMBUtil.writeInt4(count, buffer, 4);
            SMBUtil.writeInt4(remaining, buffer, 8);
            SMBUtil.writeInt4(0, buffer, 12);
            SMBUtil.writeInt4(0, buffer, 16);
            return buffer;
        }
    }

            byte[] buffer1 = new byte[256];
            byte[] buffer2 = new byte[256];

            // Encode to different buffers
            int result1 = request.encode(buffer1, 0);
            int result2 = request.encode(buffer2, 50);

            // Both should succeed independently
            assertTrue(result1 > 0);

        assertEquals(32, SMBUtil.readInt2(buffer, offset));

        // Verify notify flags
        assertEquals(Smb2ChangeNotifyRequest.SMB2_WATCH_TREE, SMBUtil.readInt2(buffer, offset + 2));

        // Verify output buffer length
        assertEquals(8192, SMBUtil.readInt4(buffer, offset + 4));

        // Verify file ID
        byte[] readFileId = new byte[16];
        System.arraycopy(buffer, offset + 8, readFileId, 0, 16);

        byte[] buffer1 = new byte[request.size()];
        byte[] buffer2 = new byte[request.size()];

        request.encode(buffer1, 0);
        request.encode(buffer2, 0);

        assertArrayEquals(buffer1, buffer2);
    }

    @Test
    @DisplayName("Test encode with insufficient buffer throws exception")
    void testEncodeWithInsufficientBuffer() {

        // Skip 7 reserved bytes (1-7)
        // Skip 8 bytes for RootDirectory (8-15)
        SMBUtil.writeInt4(nameBytes.length, buffer, 16);
        System.arraycopy(nameBytes, 0, buffer, 20, nameBytes.length);

        FileRenameInformation2 info = new FileRenameInformation2();
        int bytesRead = info.decode(buffer, 0, buffer.length);

        assertEquals(20 + nameBytes.length, bytesRead);

        // Test multiple calls to readDataWireFormat to ensure buffer is overwritten
        byte[] firstData = "First data set".getBytes();
        byte[] secondData = "Second data set".getBytes();
        byte[] buffer1 = new byte[100];
        byte[] buffer2 = new byte[100];

        System.arraycopy(firstData, 0, buffer1, 0, firstData.length);
        System.arraycopy(secondData, 0, buffer2, 0, secondData.length);

        // First read

                final int _bufferl = length / 2;
                final int _buffers = maximum_length / 2;
                _dst.enc_ndr_long(_buffers);
                _dst.enc_ndr_long(0);
                _dst.enc_ndr_long(_bufferl);
                final int _bufferi = _dst.index;
                _dst.advance(2 * _bufferl);

                _dst = _dst.derive(_bufferi);
                for (int _i = 0; _i < _bufferl; _i++) {