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

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.

        writeInt8(buffer, dataOffset + 24, leaseDuration);  // LeaseDuration
        
        if (isV2()) {
            System.arraycopy(parentLeaseKey.getKey(), 0, buffer, dataOffset + 32, 16);  // ParentLeaseKey
            writeInt2(buffer, dataOffset + 48, epoch);  // Epoch
            writeInt2(buffer, dataOffset + 50, 0);  // Reserved
        }
    }
    
    @Override

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

            int bytesWritten = context.encode(buffer, 0);

            assertEquals(12, bytesWritten);
            assertEquals(3, SMBUtil.readInt2(buffer, 0));
            assertEquals(2, SMBUtil.readInt2(buffer, 2));
            assertEquals(0x01, SMBUtil.readInt2(buffer, 4));
            assertEquals(0x02, SMBUtil.readInt2(buffer, 6));
            assertEquals(0x03, SMBUtil.readInt2(buffer, 8));

    }

    @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

     */
    @Test
    void testReadSetupWireFormat() {
        byte[] buffer = new byte[10];
        int result = netServerEnum2.readSetupWireFormat(buffer, 0, 10);
        assertEquals(0, result);
    }

    /**
     * Test the readParametersWireFormat method.
     */
    @Test
    void testReadParametersWireFormat() {
        byte[] buffer = new byte[10];

        bufferIndex += 4;
        this.grantedAccess = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.fileType = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.deviceState = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.action = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;