val body = body("")
    assertThat(body.bytes().size).isEqualTo(0)
  }

  @Test
  fun bytesSeesBom() {
    val body = body("efbbbf68656c6c6f")
    val bytes = body.bytes()
    assertThat(bytes[0] and 0xff).isEqualTo(0xef)
    assertThat(bytes[1] and 0xff).isEqualTo(0xbb)
    assertThat(bytes[2] and 0xff).isEqualTo(0xbf)
    assertThat(String(bytes, 3, 5, StandardCharsets.UTF_8)).isEqualTo("hello")
  }

        final byte[] bytes = new byte[4];
        readFully(bytes);

        final byte[] sidBytes = new byte[8 + bytes.length];
        sidBytes[0] = 1;
        sidBytes[1] = (byte) (bytes.length / 4);
        System.arraycopy(new byte[] { 0, 0, 0, 0, 0, 5 }, 0, sidBytes, 2, 6);
        System.arraycopy(bytes, 0, sidBytes, 8, bytes.length);

        return new SID(sidBytes, 0);
    }

  }

  public void testString() {
    Random random = new Random();
    for (int i = 0; i < 100; i++) {
      byte[] bytes = new byte[64];
      random.nextBytes(bytes);
      String s = new String(bytes, UTF_16LE); // so all random strings are valid
      assertEquals(
          new Sink(4).putUnencodedChars(s).hash(),
          new Sink(4).putBytes(s.getBytes(UTF_16LE)).hash());

     * </p>
     *
     * @param bytes the byte array to deserialize
     * @return the deserialized object
     */
    protected Object deserializeWithKryo(final byte[] bytes) {
        final Kryo kryo = kryoThreadLocal.get();
        try (final Input input = new Input(new ByteArrayInputStream(bytes))) {
            return kryo.readClassAndObject(input);
        }
    }

	processIOReadBytesMD              = NewCounterMD(processIOReadBytes, "Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes")

  }

  @Override
  public void write(int b) throws IOException {
    hasher.putByte((byte) b);
    out.write(b);
  }

  @Override
  public void write(byte[] bytes, int off, int len) throws IOException {
    hasher.putBytes(bytes, off, len);
    out.write(bytes, off, len);
  }

  /**
   * Returns the {@link HashCode} based on the data written to this stream. The result is

     * @param off
     *            offset into buffer
     * @param len
     *            read up to <code>len</code> bytes
     * @return number of bytes read
     * @throws SmbException if an I/O error occurs during read
     */
    int read(byte[] b, int off, int len) throws SmbException;

    /**
     * Current position in file
     *
     * @return current position
     */
    long getFilePointer();

    /**

    }
    if (value <= -1.0) {
      return -1.0;
    }
    return value;
  }

  // Serialization helpers

  /** The size of byte array representation in bytes. */
  private static final int BYTES = Stats.BYTES * 2 + Double.SIZE / Byte.SIZE;

  /**
   * Gets a byte array representation of this instance.
   *
   * <p><b>Note:</b> No guarantees are made regarding stability of the representation between

| `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                                   |

		b, e := io.ReadAll(r)
		if e != nil {
			return nil, e
		}
		b, _, minor, e := checkXL2V1(b)
		if e != nil {
			return nil, e
		}

		buf := bytes.NewBuffer(nil)
		var data xlMetaInlineData
		switch minor {
		case 0:
			_, e = msgp.CopyToJSON(buf, bytes.NewReader(b))
			if e != nil {
				return nil, e
			}
		case 1, 2:
			v, b, e := msgp.ReadBytesZC(b)
			if e != nil {
				return nil, e
			}