(byte) 0xef, (byte) 0xcd, (byte) 0xab, (byte) 0x00,
                (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00
              },
              0x00abcdef,
              0x0000000000abcdefL,
              "efcdab0000000000"));

  // expectedHashCodes must contain at least one hash code with 4 bytes
  public void testFromInt() {
    for (ExpectedHashCode expected : expectedHashCodes) {

    hasher = HASH_FN.newHasher();
    hasher
        .putByte((byte) 0x01)
        .putByte((byte) 0x01)
        .putByte((byte) 0x00)
        .putByte((byte) 0x01)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00)
        .putByte((byte) 0x00);
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher

        ASN1ObjectIdentifier[] mechs = new ASN1ObjectIdentifier[] { OID_KRB, OID_NTLM };
        int flags = NegTokenInit.DELEGATION | NegTokenInit.MUTUAL_AUTHENTICATION | NegTokenInit.INTEGRITY;
        byte[] mechToken = new byte[] { 0x01, 0x02, 0x03 };
        byte[] mic = new byte[] { (byte) 0xFE, 0x55 };

        NegTokenInit init = new NegTokenInit(mechs, flags, mechToken, mic);
        byte[] bytes = init.toByteArray();

                (byte) 0xef, (byte) 0xcd, (byte) 0xab, (byte) 0x00,
                (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00
              },
              0x00abcdef,
              0x0000000000abcdefL,
              "efcdab0000000000"));

  // expectedHashCodes must contain at least one hash code with 4 bytes
  public void testFromInt() {
    for (ExpectedHashCode expected : expectedHashCodes) {

            // Arrange
            context = new PreauthIntegrityNegotiateContext();
            byte[] buffer = new byte[] { 0x02, 0x00, // 2 hash algos
                    0x04, 0x00, // 4 bytes salt
                    0x01, 0x00, // SHA512
                    0x02, 0x00, // Another hash algo
                    0x0A, 0x0B, 0x0C, 0x0D // Salt
            };

            // Act

        return Stream.of(Arguments.of(0x1234, 0L, new byte[] { 0x34, 0x12, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }),
                // negative fid wraps around, lastWriteTime = 1000 -> 1 second -> int value 1
                Arguments.of(-1, 1000L, new byte[] { (byte) 0xFF, (byte) 0xFF, 0x01, 0x00, 0x00, 0x00 }));
    }

    /**
     * When lastWriteTime is zero the encoded unsigned time must be all 1s.

        buffer[38] = 0x00;

        // Parameter count (2 bytes)
        buffer[39] = 0x00;
        buffer[40] = 0x00;

        // Parameter offset (2 bytes)
        buffer[41] = 0x00;
        buffer[42] = 0x00;

        // Parameter displacement (2 bytes)
        buffer[43] = 0x00;
        buffer[44] = 0x00;

        // Data count (2 bytes)
        buffer[45] = 0x00;
        buffer[46] = 0x00;

            dst[dstIndex] = (byte) 0x01;
        }
        dstIndex++;
        writeInt2(this.length, dst, dstIndex);
        return HEADER_LENGTH;
    }

    int readHeaderWireFormat(final InputStream in, final byte[] buffer, int bufferIndex) {
        this.type = buffer[bufferIndex] & 0xFF;
        bufferIndex++;
        this.length = ((buffer[bufferIndex] & 0x01) << 16) + readInt2(buffer, bufferIndex + 1);

        new byte[] {
          0x01, (byte) 0xc0, 0x00, 0x00,
          0x00, 0x00, 0x00, 0x00,
          0x00, 0x00, 0x00, 0x00,
          0x00, 0x00, 0x00, 0x00,
          0x14, 0x00, 0x00, 0x00,
          0x00, 0x00, 0x04, 0x00,
          0x00, 0x00, 0x00, 0x14,
          0x00, 0x00, 0x00, 0x18,
          0x28, 0x00, 0x00, 0x00,
          0x00, 0x00, 0x00, 0x00,
          0x02, 0x00, 0x00, 0x00,

        byte[] rawBytes = new byte[] { 0x01, 0x02, 0x03, 0x04 }; // Represents 0x04030201 (little-endian)
        AvFlags avFlags = new AvFlags(rawBytes);
        assertNotNull(avFlags, "AvFlags object should not be null");
        assertEquals(0x04030201, avFlags.getFlags(), "Flags should match the raw bytes (little-endian)");

        // Test with zero
        byte[] zeroBytes = new byte[] { 0x00, 0x00, 0x00, 0x00 };