class HMACT64Test {

    private static final byte[] TEST_KEY = "testkey".getBytes();
    private static final byte[] LONG_TEST_KEY = new byte[80]; // Longer than 64 bytes
    private static final byte[] SHORT_TEST_KEY = "short".getBytes();
    private static final byte[] TEST_DATA = "testdata".getBytes();
    private static final byte[] EMPTY_DATA = new byte[0];

    static {
        // Initialize long key with predictable data

    @Test
    void testWriteSetupWireFormat() {
        byte[] dst = new byte[10];
        int result = response.writeSetupWireFormat(dst, 0);
        assertEquals(0, result, "writeSetupWireFormat should always return 0.");
    }

    /**
     * Tests the writeParametersWireFormat method.
     */
    @Test
    void testWriteParametersWireFormat() {
        byte[] dst = new byte[10];

            request.setPadding((byte) 4);
            request.setReadFlags((byte) 0x02);

            // Update file ID
            byte[] newFileId = new byte[16];
            Arrays.fill(newFileId, (byte) 0xEF);
            request.setFileId(newFileId);

            // Write and verify
            byte[] buffer = new byte[256];

}{
	{
		SealExtKey: [32]byte{}, SealIV: [32]byte{}, SealDomain: "SSE-C", SealBucket: "bucket", SealObject: "object",
		UnsealExtKey: [32]byte{}, UnsealDomain: "SSE-C", UnsealBucket: "bucket", UnsealObject: "object",
		ShouldPass: true,
	}, // 0
	{
		SealExtKey: [32]byte{}, SealIV: [32]byte{}, SealDomain: "SSE-C", SealBucket: "bucket", SealObject: "object",

        for (int i = 0; i < 24; i++) {
            assertEquals((byte) 0xAA, resumeKey[i], "Resume key byte " + i + " should be 0xAA");
        }
    }

    @Test
    @DisplayName("Test decode throws exception when length is too short")
    void testDecodeThrowsExceptionWhenLengthTooShort() {
        byte[] buffer = new byte[28];

        // Test with len = 23 (one byte too short)

        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
     */

    /**
     * Decodes a 16-bit unsigned integer from big-endian byte order.
     *

        byte[] emptyData = new byte[8];

        PACDecodingException e = assertThrows(PACDecodingException.class, () -> new Pac(emptyData, keys));
        // Any PACDecodingException is acceptable for this test
        assertNotNull(e.getMessage());
    }

    @Test
    void testTooSmallPac() {
        // Test that PAC smaller than 8 bytes is rejected
        byte[] smallData = new byte[4];

    }

    // Test constructor with external hashes
    @Test
    void testConstructorWithExternalHashes() {
        byte[] challenge = new byte[8];
        byte[] ansiHash = new byte[24];
        byte[] unicodeHash = new byte[24];
        NtlmPasswordAuthentication auth = new NtlmPasswordAuthentication("DOMAIN", "user", challenge, ansiHash, unicodeHash);
        assertEquals("DOMAIN", auth.getDomain());

    /**
     * Size of the transform header in bytes
     */
    public static final int TRANSFORM_HEADER_SIZE = 52;

    private final byte[] signature = new byte[16];
    private final byte[] nonce = new byte[16];
    private int originalMessageSize;
    private int flags;
    private long sessionId;

    /**
     * Create a new SMB2 Transform Header
     */

	testCases := []struct {
		data           []byte
		expectedResult *FilterRule
		expectErr      bool
	}{
		{[]byte(`<FilterRule></FilterRule>`), nil, true},
		{[]byte(`<FilterRule><Name></Name></FilterRule>`), nil, true},
		{[]byte(`<FilterRule><Value></Value></FilterRule>`), nil, true},
		{[]byte(`<FilterRule><Name></Name><Value></Value></FilterRule>`), nil, true},