DataOutputStream dos = new DataOutputStream(baos);

        // Write header with invalid version
        dos.writeInt(Integer.reverseBytes(1)); // 1 buffer
        dos.writeInt(Integer.reverseBytes(999)); // Invalid version

        // Add minimal buffer entry
        dos.writeInt(Integer.reverseBytes(PacConstants.LOGON_INFO));
        dos.writeInt(Integer.reverseBytes(10));
        dos.writeLong(Long.reverseBytes(100));

     */
    @Override
    protected void haveResponse(final byte[] buffer, final int start, final int len) throws SMBProtocolDecodingException {
        if (isRetainPayload()) {
            final byte[] payload = new byte[len];
            System.arraycopy(buffer, start, payload, 0, len);
            setRawPayload(payload);
        }

        if (!verifySignature(buffer, start, len)) {

        return new Smb2WriteResponse(tc.getConfig());
    }

    /**
     * Sets the data to be written to the file.
     *
     * @param data the data buffer to write
     * @param offset the offset in the data buffer
     * @param length the number of bytes to write
     */
    public void setData(final byte[] data, final int offset, final int length) {
        this.data = data;

        return 0;
    }

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

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

    @Override
    public String toString() {

      }
    }

  private fun gzip(data: String): Buffer {
    val result = Buffer()
    val sink = GzipSink(result).buffer()
    sink.writeUtf8(data)
    sink.close()
    return result
  }

  private fun addInterceptor(
    network: Boolean,
    interceptor: Interceptor,
  ) {
    val builder = client.newBuilder()
    if (network) {
      builder.addNetworkInterceptor(interceptor)

		t.Error("NewReaderSize did not detect underlying Reader")
	}
	// Does it wrap if existing buffer is too small?
	b2 := NewReaderSize(b, 2*BufSize)
	if b2 == b {
		t.Error("NewReaderSize did not enlarge buffer")
	}
}

func TestNewWriterSizeIdempotent(t *testing.T) {
	const BufSize = 1000
	b := NewWriterSize(new(bytes.Buffer), BufSize)
	// Does it recognize itself?
	b1 := NewWriterSize(b, BufSize)
	if b1 != b {

	}
}

// Test the line splitter, including some carriage returns but no long lines.
func TestScanLongLines(t *testing.T) {
	// Build a buffer of lots of line lengths up to but not exceeding smallMaxTokenSize.
	tmp := new(bytes.Buffer)
	buf := new(bytes.Buffer)
	lineNum := 0
	j := 0
	for i := 0; i < 2*smallMaxTokenSize; i++ {
		genLine(tmp, lineNum, j, true)
		if j < smallMaxTokenSize {
			j++
		} else {

    }

    @Override
    public int read(ByteBuffer buffer, long remoteAddress, int remoteKey, int length) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED) {
            throw new IOException("Connection not established");
        }

        try {
            // In real implementation, this would perform RDMA read into the buffer

  private val controlFrameBuffer = Buffer()
  private val messageFrameBuffer = Buffer()

  /** Lazily initialized on first use. */
  private var messageInflater: MessageInflater? = null

  // Masks are only a concern for server writers.
  private val maskKey: ByteArray? = if (isClient) null else ByteArray(4)
  private val maskCursor: Buffer.UnsafeCursor? = if (isClient) null else Buffer.UnsafeCursor()

  interface FrameCallback {

        return 0;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        this.count = SMBUtil.readInt2(buffer, bufferIndex) & 0xFFFFL;
        return 8;
    }

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

    @Override
    public String toString() {