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[] buffer2 = testCache.getBuffer();

        // Then
        assertNotNull(buffer1, "First buffer should not be null");
        assertNotNull(buffer2, "Second buffer should not be null");
        assertEquals(1024, buffer1.length, "Buffer should have expected size");
        assertEquals(1024, buffer2.length, "Buffer should have expected size");

        offset += 4;
        SMBUtil.writeInt4(2000, buffer2, offset); // alloc
        offset += 4;
        SMBUtil.writeInt4(1000, buffer2, offset); // free
        offset += 4;
        SMBUtil.writeInt2(1024, buffer2, offset); // bytesPerSect

        smbInfoAllocation.decode(buffer2, 0, buffer2.length);

        // Verify values are updated

        // Write to buffer
        SMBUtil.writeInt4(testCapabilities, buffer, bufferIndex);
        System.arraycopy(testGuid, 0, buffer, bufferIndex + 4, 16);
        SMBUtil.writeInt2(testSecurityMode, buffer, bufferIndex + 20);
        SMBUtil.writeInt2(testDialect, buffer, bufferIndex + 22);

        // Execute decode
        int bytesDecoded = response.decode(buffer, bufferIndex, 24);

        // Verify results

            byte[] buffer1 = new byte[1024];
            int bytesRead1 = stream1.read(buffer1);
            assertEquals(testContent, new String(buffer1, 0, bytesRead1, "UTF-8"));
        }

        // Second read - should work independently
        try (InputStream stream2 = cache.getInputStream()) {
            byte[] buffer2 = new byte[1024];
            int bytesRead2 = stream2.read(buffer2);

        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() {

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

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

        fileInternalInfo.decode(buffer2, 0, buffer2.length);
        assertEquals(indexNumber2, fileInternalInfo.getIndexNumber());

        // Third decode - should overwrite again
        byte[] buffer3 = new byte[8];
        long indexNumber3 = 0x3333333333333333L;
        SMBUtil.writeInt8(indexNumber3, buffer3, 0);
        fileInternalInfo.decode(buffer3, 0, buffer3.length);

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