| `minio_node_replication_average_transfer_rate`          | Average replication transfer rate in bytes/sec                                                           |
| `minio_node_replication_max_transfer_rate`              | Maximum replication transfer rate in bytes/sec seen since server start                                   |

   * @throws IllegalArgumentException if {@code bytes} has fewer than 2 elements
   */
  @GwtIncompatible // doesn't work
  public static char fromByteArray(byte[] bytes) {
    checkArgument(bytes.length >= BYTES, "array too small: %s < %s", bytes.length, BYTES);
    return fromBytes(bytes[0], bytes[1]);
  }

  /**
   * Returns the {@code char} value whose byte representation is the given 2 bytes, in big-endian

   * @throws IllegalArgumentException if {@code bytes} has fewer than 2 elements
   */
  @GwtIncompatible // doesn't work
  public static short fromByteArray(byte[] bytes) {
    checkArgument(bytes.length >= BYTES, "array too small: %s < %s", bytes.length, BYTES);
    return fromBytes(bytes[0], bytes[1]);
  }

  /**
   * Returns the {@code short} value whose byte representation is the given 2 bytes, in big-endian

    void testWriteBytesWireFormat() throws UnsupportedEncodingException {
        byte[] expectedBytes = DIALECTS.getBytes("ASCII");
        byte[] dst = new byte[expectedBytes.length];
        int dstIndex = 0;

        // Execute the method to write bytes
        int bytesWritten = smbComNegotiate.writeBytesWireFormat(dst, dstIndex);

        // Verify the number of bytes written

    }

    /**
     * Gets the number of bytes written.
     *
     * @return the count of bytes written
     */
    public final long getCount() {
        return this.count;
    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;

func NewChecker(rc io.ReadCloser, h hash.Hash, wantSum []byte, length int64) *Checker {
	return &Checker{c: rc, r: ioutil.HardLimitReader(rc, length), h: h, want: wantSum}
}

// Read satisfies io.Reader
func (c Checker) Read(p []byte) (n int, err error) {
	n, err = c.r.Read(p)
	if n > 0 {
		c.h.Write(p[:n])
	}
	if errors.Is(err, io.EOF) {
		got := c.h.Sum(nil)
		if !bytes.Equal(got, c.want) {
			return n, ErrInvalidChecksum
		}

	PolicyConfigJSON            []byte
	NotificationConfigXML       []byte
	LifecycleConfigXML          []byte
	ObjectLockConfigXML         []byte
	VersioningConfigXML         []byte
	EncryptionConfigXML         []byte
	TaggingConfigXML            []byte
	QuotaConfigJSON             []byte
	ReplicationConfigXML        []byte
	BucketTargetsConfigJSON     []byte
	BucketTargetsConfigMetaJSON []byte

            andxCommand = (byte) 0xFF;
            andx = null;

            dst[start + ANDX_COMMAND_OFFSET] = (byte) 0xFF;
            dst[start + ANDX_RESERVED_OFFSET] = (byte) 0x00;
            //            dst[start + ANDX_OFFSET_OFFSET] = (byte)0x00;
            //            dst[start + ANDX_OFFSET_OFFSET + 1] = (byte)0x00;
            dst[start + ANDX_OFFSET_OFFSET] = (byte) 0xde;

    @Override
    public Hasher putByte(byte b) {
      update(1, b & 0xFF);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Hasher putBytes(byte[] bytes, int off, int len) {
      checkPositionIndexes(off, off + len, bytes.length);
      int i;
      for (i = 0; i + 4 <= len; i += 4) {
        update(4, getIntLittleEndian(bytes, off + i));
      }
      for (; i < len; i++) {

        byte[] src = new byte[10];
        int srcIndex = 0;

        // Simulate groupName = false, nodeType = 0
        src[srcIndex] = (byte) 0x00;
        src[srcIndex + 1] = (byte) 0x00;

        // Simulate address = 0.0.0.0
        src[srcIndex + 2] = (byte) 0x00;
        src[srcIndex + 3] = (byte) 0x00;
        src[srcIndex + 4] = (byte) 0x00;
        src[srcIndex + 5] = (byte) 0x00;