const val FLAG_END_HEADERS = 0x4 // Used for headers and continuation.
  const val FLAG_END_PUSH_PROMISE = 0x4
  const val FLAG_PADDED = 0x8 // Used for headers and data.
  const val FLAG_PRIORITY = 0x20 // Used for headers.
  const val FLAG_COMPRESSED = 0x20 // Used for data.

  /** Lookup table for valid frame types. */
  private val FRAME_NAMES =
    arrayOf(
      "DATA",
      "HEADERS",
      "PRIORITY",
      "RST_STREAM",

        // Verify that flags are set correctly (DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG)
        // The actual values for DCERPC_FIRST_FRAG and DCERPC_LAST_FRAG are typically 0x01 and 0x02 respectively.
        int expectedFlags = 0x01 | 0x02; // DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG
        assertEquals(expectedFlags, msrpcSamrOpenDomain.getFlags(), "flags should be initialized to DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");

        }

        return clearText;
    }

    // Tables, permutations, S-boxes, etc.

    private static byte[] bytebit =
            { (byte) 0x80, (byte) 0x40, (byte) 0x20, (byte) 0x10, (byte) 0x08, (byte) 0x04, (byte) 0x02, (byte) 0x01 };
    private static int[] bigbyte = { 0x800000, 0x400000, 0x200000, 0x100000, 0x080000, 0x040000, 0x020000, 0x010000, 0x008000, 0x004000,

        assertEquals(0xF, PacConstants.DEVICE_CLAIMS_TYPE, "DEVICE_CLAIMS_TYPE should be 0xF");

        // Verify PAC logon info constants
        assertEquals(0x20, PacConstants.LOGON_EXTRA_SIDS, "LOGON_EXTRA_SIDS should be 0x20");
        assertEquals(0x200, PacConstants.LOGON_RESOURCE_GROUPS, "LOGON_RESOURCE_GROUPS should be 0x200");

        // Verify cryptographic constants

  }

  @Test
  fun flagOverlapOn0x20() {
    assertThat(frameLog(true, 3, 10000, TYPE_HEADERS, 0x20))
      .isEqualTo("<< 0x00000003 10000 HEADERS       PRIORITY")
    assertThat(frameLog(true, 3, 10000, TYPE_DATA, 0x20))
      .isEqualTo("<< 0x00000003 10000 DATA          COMPRESSED")
  }

  /**

class AvChannelBindingsTest {

    /**
     * Test that the constructor correctly initializes with a valid channel binding hash.
     */
    @Test
    void testConstructorWithValidHash() {
        byte[] testHash = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
        AvChannelBindings avChannelBindings = new AvChannelBindings(testHash);

            int bufferIndex = 0;

            // Write structure size (24)
            SMBUtil.writeInt2(24, buffer, bufferIndex);

            // Write oplock level at offset 2
            byte expectedOplockLevel = (byte) 0x02; // SMB2_OPLOCK_LEVEL_II
            buffer[bufferIndex + 2] = expectedOplockLevel;

            // Write reserved field (4 bytes at offset 4)
            bufferIndex += 4;

            // Write Reserved2 (4 bytes)

        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };

        assertDoesNotThrow(() -> digest.update(data, 0, data.length));
    }

    @Test
    @DisplayName("Test update method with zero length")
    void testUpdateWithZeroLength() {
        SMB1SigningDigest digest = new SMB1SigningDigest(testMacSigningKey);
        byte[] data = new byte[] { 0x01, 0x02, 0x03, 0x04 };

        // State 1: Generate Type 1 message
        context.initSecContext(new byte[0], 0, 0);

        // Create a mock Type 2 message (server challenge)
        byte[] serverChallenge = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
        int type2Flags = NtlmFlags.NTLMSSP_NEGOTIATE_NTLM | NtlmFlags.NTLMSSP_REQUEST_TARGET | NtlmFlags.NTLMSSP_NEGOTIATE_KEY_EXCH
                | NtlmFlags.NTLMSSP_NEGOTIATE_SIGN;

        // Tag [1] IMPLICIT, content is 0x01 0x02 0x03
        byte[] data = new byte[] { (byte) 0xA1, 0x03, 0x01, 0x02, 0x03 };
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        ASN1InputStream ais = new ASN1InputStream(bais);
        byte[] result = ASN1Util.readUnparsedTagged(1, 10, ais);
        assertArrayEquals(new byte[] { 0x01, 0x02, 0x03 }, result);
    }

    @Test