}
  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
    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;

        byte[] buffer = new byte[37]; // 3 reserved + 8*4 bytes for int4 values + 2 bytes for setupCount
        int bufferIndex = 0;

        // Reserved bytes
        buffer[bufferIndex++] = 0x00;
        buffer[bufferIndex++] = 0x00;
        buffer[bufferIndex++] = 0x00;

        // totalParameterCount = 10
        writeInt4(10, 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));

        byte[] buffer = new byte[256];
        int written = trans2FindFirst2.writeParametersWireFormat(buffer, 0);

        assertEquals(0, SMBUtil.readInt2(buffer, 0)); // search attributes
        assertEquals(0, SMBUtil.readInt2(buffer, 2)); // max items
    }

    // Helper method to read string from buffer
    private String readStringFromBuffer(byte[] buffer, int offset, int length) {

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

                SmbComReadAndX readCmd = invocation.getArgument(0);
                SmbComReadAndXResponse response = invocation.getArgument(1);
                response.dataLength = 1;
                // The response buffer points to the internal tmp buffer
                if (response.b != null && response.off < response.b.length) {
                    response.b[response.off] = 42; // Return byte value 42
                }
                return null;

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

        // Encode first
        byte[] buffer = new byte[256];
        int encodedSize = context.encode(buffer, 0);

        // Create new context for decoding
        CompressionNegotiateContext decodedContext = new CompressionNegotiateContext();
        int decodedSize = decodedContext.decode(buffer, 0, encodedSize);

        assertEquals(encodedSize, decodedSize);

    /**
     * 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