ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        EnumSet<RdmaAccess> access = EnumSet.of(RdmaAccess.LOCAL_READ, RdmaAccess.LOCAL_WRITE);

        RdmaMemoryRegion region = provider.registerMemory(buffer, access);
        assertNotNull(region, "Memory region should not be null");
        assertEquals(buffer, region.getBuffer(), "Buffer should match");

     *
     * @param buffer the buffer containing the message data
     * @param bufferIndex the starting offset in the buffer
     * @return the number of bytes read
     */
    protected int readHeaderWireFormat(final byte[] buffer, final int bufferIndex) {
        this.command = buffer[bufferIndex + SmbConstants.CMD_OFFSET];
        this.errorCode = SMBUtil.readInt4(buffer, bufferIndex + SmbConstants.ERROR_CODE_OFFSET);

import mockwebserver3.MockResponseBody
import okio.Buffer
import okio.BufferedSink

internal fun Buffer.toMockResponseBody(): MockResponseBody {
  val defensiveCopy = clone()
  return BufferMockResponseBody(defensiveCopy)
}

internal class BufferMockResponseBody(
  val buffer: Buffer,
) : MockResponseBody {
  override val contentLength = buffer.size

  override fun writeTo(sink: BufferedSink) {

```go
	rb := ringbuffer.New(1024).SetBlocking(true)
```

Enabling blocking will cause the ring buffer to behave like a buffered [io.Pipe](https://pkg.go.dev/io#Pipe).

Regular Reads will block until data is available, but not wait for a full buffer. 
Writes will block until there is space available and writes bigger than the buffer will wait for reads to make space.

`TryRead` and `TryWrite` are still available for non-blocking reads and writes.

    protected int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    protected int readParametersWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        final int start = bufferIndex;

        setStatus(SMBUtil.readInt2(buffer, bufferIndex));
        bufferIndex += 2;
        this.converter = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;

        assertEquals((byte) 0xEF, buffer[0]); // Little-endian
        assertEquals((byte) 0xCD, buffer[1]);
        assertEquals((byte) 0xAB, buffer[2]);
        assertEquals((byte) 0x89, buffer[3]);
        assertEquals((byte) 0x67, buffer[4]);
        assertEquals((byte) 0x45, buffer[5]);
        assertEquals((byte) 0x23, buffer[6]);
        assertEquals((byte) 0x01, buffer[7]);

        ndrBuffer.setIndex(0);

        byte[] buffer = new byte[8];
        int bufferIndex = 0;

        SMBUtil.writeInt2(status, buffer, bufferIndex);
        bufferIndex += 2;
        SMBUtil.writeInt2(0, buffer, bufferIndex);
        bufferIndex += 2;
        SMBUtil.writeInt2(0, buffer, bufferIndex);
        bufferIndex += 2;
        SMBUtil.writeInt2(0, buffer, bufferIndex);

            assertEquals(0, echoResponse.writeBytesWireFormat(buffer, 100));
            assertEquals(0, echoResponse.writeBytesWireFormat(buffer, 500));
        }

        @Test
        @DisplayName("Should not modify buffer")
        void testWriteBytesWireFormatNoModification() {
            byte[] buffer = new byte[1024];
            byte[] originalBuffer = buffer.clone();

    /**
     * Constructs a SMB2 read response with the specified configuration and output buffer
     *
     * @param config
     *            the configuration to use for this response
     * @param outputBuffer
     *            the buffer to receive the read data
     * @param outputBufferOffset
     *            the offset in the output buffer to start writing data
     */

    }

    @Override
    protected void process(ByteBuffer buffer) {
      b += CHUNK_SIZE;
      processM(buffer.getLong());
    }

    @Override
    protected void processRemaining(ByteBuffer buffer) {
      b += buffer.remaining();
      for (int i = 0; buffer.hasRemaining(); i += 8) {
        finalM ^= (buffer.get() & 0xFFL) << i;
      }
    }

    @Override