```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.

import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.Request
import okhttp3.containers.BasicMockServerTest.Companion.MOCKSERVER_IMAGE
import okhttp3.containers.BasicMockServerTest.Companion.trustMockServer
import okio.buffer
import okio.source
import org.junit.jupiter.api.Test
import org.mockserver.client.MockServerClient
import org.mockserver.configuration.Configuration
import org.mockserver.logging.MockServerLogger

     * @param fid the file identifier
     * @param offset the file offset at which to write
     * @param remaining the number of bytes remaining to be written
     * @param b the data buffer containing bytes to write
     * @param off the offset in the buffer where data starts
     * @param len the number of bytes to write
     * @param andx the next command in the AndX chain, or null
     */

    }

    @Test
    @DisplayName("Should decode transform header from byte buffer")
    void testDecodeFromBuffer() {
        // Given
        byte[] buffer = new byte[52];
        int index = 0;

        // Protocol ID - 0xFD534D42 in little-endian
        buffer[index++] = (byte) 0x42;
        buffer[index++] = (byte) 0x4D;
        buffer[index++] = (byte) 0x53;

        final int start = bufferIndex;

        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 9) {
            throw new SMBProtocolDecodingException("Expected structureSize = 9");
        }

        final int bufferOffset = SMBUtil.readInt2(buffer, bufferIndex + 2) + getHeaderStart();

    }

    @Override
    public String toString() {
        StringBuilder buffer = new StringBuilder(128);

        buffer.append('[').append(getSeverity()).append("] ");
        buffer.append(getMessage());
        buffer.append(" @ ").append(ModelProblemUtils.formatLocation(this, null));

        return buffer.toString();
    }

        void testVerifySignatureSuccess() {
            byte[] buffer = new byte[100];
            response.setDigest(mockDigest);
            when(mockDigest.verify(buffer, 0, 100, 0, response)).thenReturn(false);

            boolean result = response.verifySignature(buffer, 0, 100);

            assertTrue(result);
            assertFalse(response.isVerifyFailed());
        }

    /**
     * Verifies the signature of this response.
     *
     * @param buffer the buffer containing the signature data
     * @param i the starting index in the buffer
     * @param size the size of the signature data
     * @return whether signature verification is successful
     */
    boolean verifySignature(byte[] buffer, int i, int size);

    /**
     * Checks if signature verification failed.
     *

                if (!currentArg.isEmpty()) {
                    currentArg.setLength(currentArg.length() - 1);
                }

                cleaned.add(currentArg.toString());

                currentArg = null;
                continue;
            }

            // if we haven't added this arg to the buffer, and we ARE building an argument

        bufferIndex += 8;
        lastWriteTime = readTime(buffer, bufferIndex);
        bufferIndex += 8;
        changeTime = readTime(buffer, bufferIndex);
        bufferIndex += 8;
        extFileAttributes = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        allocationSize = readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        endOfFile = readInt8(buffer, bufferIndex);