import com.google.common.collect.Lists;

public class MemoryUtilTest extends UnitFessTestCase {

    public void test_byteCountToDisplaySize() {
        assertEquals("0bytes", MemoryUtil.byteCountToDisplaySize(0L));
        assertEquals("999bytes", MemoryUtil.byteCountToDisplaySize(999L));
        assertEquals("1000bytes", MemoryUtil.byteCountToDisplaySize(1000L));

    // These will have the same first 4 bytes (all 0).
    byte[] bytesA = new byte[5];
    byte[] bytesB = new byte[5];

    // Change only the last (5th) byte
    bytesA[4] = (byte) 0xbe;
    bytesB[4] = (byte) 0xef;

    HashCode hashCodeA = HashCode.fromBytes(bytesA);
    HashCode hashCodeB = HashCode.fromBytes(bytesB);

    // They aren't equal...

    // These will have the same first 4 bytes (all 0).
    byte[] bytesA = new byte[5];
    byte[] bytesB = new byte[5];

    // Change only the last (5th) byte
    bytesA[4] = (byte) 0xbe;
    bytesB[4] = (byte) 0xef;

    HashCode hashCodeA = HashCode.fromBytes(bytesA);
    HashCode hashCodeB = HashCode.fromBytes(bytesB);

    // They aren't equal...

    void testReadWithDifferentReservedValues(int byte2, int byte3) throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[256];

        // Write structure size (4)
        SMBUtil.writeInt2(4, buffer, 0);
        // Write reserved field (any value is acceptable)
        buffer[2] = (byte) byte2;
        buffer[3] = (byte) byte3;

        // When

        byte[] buffer1 = new byte[256];
        byte[] buffer2 = new byte[256];

        // When
        int bytes1 = request.writeBytesWireFormat(buffer1, 0);
        int bytes2 = request.writeBytesWireFormat(buffer2, 10);

        // Then
        assertEquals(bytes1, bytes2);
        assertEquals(SMBUtil.readInt2(buffer1, 0), SMBUtil.readInt2(buffer2, 10));

    @Test
    @DisplayName("Should generate consistent byte representation")
    void testConsistentByteRepresentation() throws IOException {
        // Given
        Type1Message type1 = new Type1Message(mockContext);

        // When
        byte[] bytes1 = type1.toByteArray();
        byte[] bytes2 = type1.toByteArray();

        // Then
        assertArrayEquals(bytes1, bytes2);
    }

    @Test

        // Encode multiple times to verify consistency
        byte[] buffer1 = new byte[8];
        byte[] buffer2 = new byte[8];

        int bytes1 = info.encode(buffer1, 0);
        int bytes2 = info.encode(buffer2, 0);

        assertEquals(8, bytes1);
        assertEquals(8, bytes2);
        assertArrayEquals(buffer1, buffer2);
    }

    @Test

    @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++) {

    @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++) {

    @Override
    public int bits() {
      return bytes.length * 8;
    }

    @Override
    public byte[] asBytes() {
      return bytes.clone();
    }

    @Override
    public int asInt() {
      checkState(
          bytes.length >= 4,
          "HashCode#asInt() requires >= 4 bytes (it only has %s bytes).",
          bytes.length);
      return (bytes[0] & 0xFF)
          | ((bytes[1] & 0xFF) << 8)