}

        return new byte[bufferSize];
    }

    static void getBuffers(final SmbComTransaction req, final SmbComTransactionResponse rsp) {
        req.txn_buf = getBuffer();
        rsp.txn_buf = getBuffer();
    }

    /**
     * Returns a buffer to the cache for reuse.
     *
     * Performance: O(1) operation with size limit check
     *

                req.maxBufferSize = snd_buf_size;
                resp.reset();

                try {
                    BufferCache.getBuffers(req, resp);

                    /*
                     * First request w/ interim response
                     */

                    req.nextElement();
                    if (req.hasMoreElements()) {

        verify(cfg, times(1)).getMaximumBufferSize();
        verifyNoMoreInteractions(cfg);

        // When cache is empty, getBuffer allocates a new buffer with configured size
        byte[] buf = impl.getBuffer();
        assertNotNull(buf, "getBuffer should never return null");
        assertEquals(5, buf.length, "Newly allocated buffer length should match config maximum size");
    }

            cache.getBuffer();
            cache.releaseBuffer(new byte[1024]);
        }, "All BufferCache interface methods should be callable");
    }

    @Test
    @DisplayName("getBuffer should return non-null byte array")
    void testGetBufferContract() {
        // Given
        byte[] expectedBuffer = new byte[1024];
        when(mockBufferCache.getBuffer()).thenReturn(expectedBuffer);

            // Test data preparation
            byte[] testData = "Test RDMA data transfer".getBytes();
            sendBuffer.getBuffer().put(testData);
            sendBuffer.getBuffer().flip();
            assertEquals(testData.length, sendBuffer.getBuffer().remaining(), "Buffer should contain test data");

            // Clean up
            bufferManager.releaseSendRegion(sendBuffer);

  private final FbosByteSource byteSource;
  private final State state;

  /** ByteArrayOutputStream that exposes its internals. */
  private static final class MemoryOutput extends ByteArrayOutputStream {
    byte[] getBuffer() {
      return buf;
    }

    int getCount() {
      return count;
    }
  }

  /** Returns the file holding the data (possibly null). */
  @VisibleForTesting
  @Nullable File getFile() {

 */
public interface BufferCache {

    /**
     * Gets a buffer from the cache or creates a new one if the cache is empty.
     *
     * @return a buffer from the cache, or a new one
     */
    byte[] getBuffer();

    /**
     * Return a buffer to the cache
     *
     * @param buf the buffer to return to the cache for reuse
     */
    void releaseBuffer(byte[] buf);

    }

    /**
     * Get the underlying buffer
     *
     * @return memory buffer
     * @throws IllegalStateException if memory region has been invalidated
     */
    public ByteBuffer getBuffer() {
        if (!valid) {
            throw new IllegalStateException("Memory region invalidated");
        }
        return buffer;
    }

    /**
     * Get local memory key
     *

        if (minSize <= sendBufferSize) {
            RdmaMemoryRegion region = availableSendRegions.poll();
            if (region != null) {
                region.getBuffer().clear();
                return region;
            }
        }

        // Allocate new buffer
        ByteBuffer buffer = ByteBuffer.allocateDirect(Math.max(minSize, sendBufferSize));

        if (this.state == 0) {
            bind();
        }
        final byte[] inB = this.transportContext.getBufferCache().getBuffer();
        final byte[] out = this.transportContext.getBufferCache().getBuffer();
        try {
            final NdrBuffer buf = encodeMessage(msg, out);
            final int off = sendFragments(msg, out, buf);