throw new IllegalArgumentException("Data buffer cannot be null");
        }
        if (offset < 0 || length < 0) {
            throw new IllegalArgumentException("Offset and length must be non-negative");
        }
        if (offset + length > data.length) {
            throw new IllegalArgumentException("Offset + length exceeds data buffer size");
        }

    }

    @Override
    int readTrailerWireFormat(final InputStream in, final byte[] buffer, int bufferIndex) throws IOException {
        if (in.read(buffer, bufferIndex, length) != length) {
            throw new IOException("unexpected EOF reading netbios retarget session response");
        }
        final int addr = readInt4(buffer, bufferIndex);
        bufferIndex += 4;

    @Test
    void testReadParameterWordsWireFormat() {
        // Given
        SmbComTreeDisconnect smbComTreeDisconnect = new SmbComTreeDisconnect();
        byte[] buffer = new byte[10];

        // When
        int result = smbComTreeDisconnect.readParameterWordsWireFormat(buffer, 0);

        // Then
        assertEquals(0, result, "readParameterWordsWireFormat should return 0");
    }

    /**

  }

  private fun ByteString.zstdCompress(): ByteString {
    val result = Buffer()
    result.zstdCompress().buffer().use {
      it.write(this@zstdCompress)
    }
    return result.readByteString()
  }

  private fun ByteString.gzipCompress(): ByteString {
    val result = Buffer()
    (result as Sink).gzip().buffer().use {
      it.write(this@gzipCompress)
    }
    return result.readByteString()

        final byte[] buffer = this.getContext().getBufferCache().getBuffer();
        try {
            // synchronize around encode and write so that the ordering for SMB1 signing can be maintained
            synchronized (this.outLock) {
                final int n = smb.encode(buffer, 4);
                Encdec.enc_uint32be(n & 0xFFFF, buffer, 0); /* 4 byte session message header */

		expectedErr error
	}
	tests := []testCase{
		// Test - 1 valid buffer with CRLF.
		{bytes.NewReader([]byte("\r\n")), nil},
		// Test - 2 invalid buffer with no CRLF.
		{bytes.NewReader([]byte("he")), errMalformedEncoding},
		// Test - 3 invalid buffer with more characters.
		{bytes.NewReader([]byte("he\r\n")), errMalformedEncoding},
		// Test - 4 smaller buffer than expected.
		{bytes.NewReader([]byte("h")), io.ErrUnexpectedEOF},
	}

        return 0;
    }

    @Override
    int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        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

        return dstIndex - start;
    }

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

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

    @Override
    public String toString() {

        "Expected at least Stats.BYTES = %s remaining , got %s",
        BYTES,
        buffer.remaining());
    return new Stats(
        buffer.getLong(),
        buffer.getDouble(),
        buffer.getDouble(),
        buffer.getDouble(),
        buffer.getDouble());
  }

  private static final long serialVersionUID = 0;

        String str = "string";
        StringBuilder builder = new StringBuilder("builder");
        StringBuffer buffer = new StringBuffer("buffer");
        String result = StringUtil.join(",", str, builder, buffer);
        assertEquals("string,builder,buffer", result);
    }

    @ParameterizedTest
    @DisplayName("Should handle various element counts")