@DisplayName("Should decode minimum buffer size")
        void testDecodeMinimumBufferSize() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[12]; // Exact size needed
            SMBUtil.writeInt4(3, buffer, 0);
            SMBUtil.writeInt4(4096, buffer, 4);
            SMBUtil.writeInt4(12288, buffer, 8);

            int bytesDecoded = response.decode(buffer, 0, buffer.length);

    }

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

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

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

  }
  return commaFound
}

private fun Buffer.startsWith(prefix: Byte): Boolean = !exhausted() && this[0] == prefix

/**
 * Reads a double-quoted string, unescaping quoted pairs like `\"` to the 2nd character in each
 * sequence. Returns the unescaped string, or null if the buffer isn't prefixed with a
 * double-quoted string.
 */
@Throws(EOFException::class)
private fun Buffer.readQuotedString(): String? {

        override fun onRetryChange(timeMs: Long) {
          callbacks.add(timeMs)
        }
      }
    val buffer = Buffer().writeUtf8(source)
    val reader = ServerSentEventReader(buffer, callback)
    while (reader.processNextEvent()) {
    }
    assertThat(buffer.size, "Unconsumed buffer: ${buffer.readUtf8()}")
      .isEqualTo(0)
  }

            assertEquals(8192L, SMBUtil.readInt8(buffer, 8)); // Offset
            assertArrayEquals(testFileId, Arrays.copyOfRange(buffer, 16, 32)); // File ID
            assertEquals(512, SMBUtil.readInt4(buffer, 32)); // Minimum count
            assertEquals(Smb2ReadRequest.SMB2_CHANNEL_NONE, SMBUtil.readInt4(buffer, 36)); // Channel
            assertEquals(1024, SMBUtil.readInt4(buffer, 40)); // Remaining bytes

    out.write(b);

    verify(hashFunction).newHasher();
    verify(hasher).putByte((byte) b);
    verifyNoMoreInteractions(hashFunction, hasher);
  }

  public void testWrite_putByteArray() throws Exception {
    byte[] buf = new byte[] {'y', 'a', 'm', 's'};
    HashingOutputStream out = new HashingOutputStream(hashFunction, buffer);
    out.write(buf);

    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.alloc = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        this.free = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        this.sectPerAlloc = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        byte[] buffer = new byte[6];
        close.writeParameterWordsWireFormat(buffer, 0);
        // first two bytes encode fid 42
        assertEquals((byte) 42, buffer[0]);
        assertEquals((byte) 0, buffer[1]);
        // remaining 4 bytes should all be 0xFF according to writeUTime
        for (int i = 2; i < 6; i++) {
            assertEquals((byte) 0xFF, buffer[i], "byte %d should be 0xFF".formatted(i));

    /**
     * Create new TCP memory region
     *
     * @param buffer memory buffer
     * @param access access permissions (ignored for TCP)
     */
    public TcpMemoryRegion(ByteBuffer buffer, EnumSet<RdmaAccess> access) {
        super(buffer, access);
    }

    @Override
    public void invalidate() {
        // No real invalidation needed for TCP

import kotlin.test.Test
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.ResponseBody.Companion.toResponseBody
import okio.Buffer
import okio.BufferedSource
import okio.ByteString.Companion.decodeHex
import okio.ByteString.Companion.encodeUtf8
import okio.IOException
import okio.Source
import okio.buffer

class ResponseBodyTest {
  @Test
  fun sourceEmpty() {