// Session ID (8 bytes) - little-endian
        buffer[index++] = (byte) (testSessionId & 0xFF);
        buffer[index++] = (byte) ((testSessionId >> 8) & 0xFF);
        buffer[index++] = (byte) ((testSessionId >> 16) & 0xFF);
        buffer[index++] = (byte) ((testSessionId >> 24) & 0xFF);
        buffer[index++] = (byte) ((testSessionId >> 32) & 0xFF);

        byte[] testSessionKey = new byte[16];
        Arrays.fill(testSessionKey, (byte) 0xAA);
        byte[] testPreauth = new byte[64];
        Arrays.fill(testPreauth, (byte) 0xBB);

        // When
        byte[] signingKey300 = Smb3KeyDerivation.deriveSigningKey(Smb2Constants.SMB2_DIALECT_0300, testSessionKey, testPreauth);

  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(byte[] bytes) {
    return putBytes(bytes, 0, bytes.length);
  }

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

  @Override

        assertEquals(expected.length, bytesWritten, "Number of bytes written should match expected length.");

        byte[] actual = new byte[bytesWritten];
        System.arraycopy(dst, 0, actual, 0, bytesWritten);

        // Use assertArrayEquals for byte array comparison
        org.junit.jupiter.api.Assertions.assertArrayEquals(expected, actual, "Byte array content should match the expected format.");
    }

    @Test

class MIENameTest {

    // Helper to build a valid buffer according to the expected layout.
    private static byte[] buildBuffer(byte[] oidDer, byte[] nameBytes) {
        byte[] tokId = new byte[] { 0x04, 0x01 };
        int oidLen = oidDer.length;
        int nameLen = nameBytes.length;

        byte[] buf = new byte[2 + 2 + oidLen + 4 + nameLen];
        int i = 0;
        // TOK_ID
        buf[i++] = tokId[0];

     */
    public static int enc_uint32le(final int i, final byte[] dst, int di) {
        dst[di] = (byte) (i & 0xFF);
        di++;
        dst[di++] = (byte) (i >> 8 & 0xFF);
        dst[di++] = (byte) (i >> 16 & 0xFF);
        dst[di] = (byte) (i >> 24 & 0xFF);
        return 4;
    }

    /* Decode integers
     */

    /**

        void testEncodeWithoutSignature() {
            byte[] buffer = new byte[1024];

            int length = testBlock.encode(buffer, 0);

            assertTrue(length > 0);
            assertEquals(length, testBlock.getLength());
            // SMB_HEADER is {0xFF, 'S', 'M', 'B'}
            byte[] expectedHeader = { (byte) 0xFF, (byte) 'S', (byte) 'M', (byte) 'B' };

}

// Bytes provides a byte slice that can be serialized.
type Bytes []byte

// UnmarshalMsg deserializes b from the provided byte slice and returns the
// remainder of bytes.
func (b *Bytes) UnmarshalMsg(bytes []byte) ([]byte, error) {
	if b == nil {
		return bytes, errors.New("Bytes: UnmarshalMsg on nil pointer")
	}
	if bytes, err := msgp.ReadNilBytes(bytes); err == nil {
		if *b != nil {
			PutByteBuffer(*b)

                (byte) 0xCC, (byte) 0xDD, (byte) 0xEE, (byte) 0xFF, 0x00 };

        Smb2LeaseKey key = new Smb2LeaseKey(testBytes);
        byte[] buffer = new byte[20];

        key.encode(buffer, 2);

        for (int i = 0; i < 16; i++) {
            assertEquals(testBytes[i], buffer[i + 2]);
        }
    }

    @Test
    @DisplayName("Should implement equals correctly")
    void testEquals() {

  public void testCollisionsDueToIncorrectSignExtension() {
    byte[] col1 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0x80};
    byte[] col2 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0x81};
    byte[] col3 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0xff};

    ImmutableSet<HashCode> hashCodes =
        ImmutableSet.of(