assertEquals(0x0, AvPair.MsvAvEOL, "MsvAvEOL constant should be 0x0.");
        assertEquals(0x6, AvPair.MsvAvFlags, "MsvAvFlags constant should be 0x6.");
        assertEquals(0x7, AvPair.MsvAvTimestamp, "MsvAvTimestamp constant should be 0x7.");
        assertEquals(0x08, AvPair.MsvAvSingleHost, "MsvAvSingleHost constant should be 0x08.");
        assertEquals(0x09, AvPair.MsvAvTargetName, "MsvAvTargetName constant should be 0x09.");

        @Test
        @DisplayName("Should set write flags")
        void testSetWriteFlags() {
            assertDoesNotThrow(() -> request.setWriteFlags(0));
            assertDoesNotThrow(() -> request.setWriteFlags(0x01));
            assertDoesNotThrow(() -> request.setWriteFlags(0xFF));
            assertDoesNotThrow(() -> request.setWriteFlags(Integer.MAX_VALUE));
        }

        @ParameterizedTest

        return 0;
    }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;
        isLoggedInAsGuest = ((buffer[bufferIndex] & 0x01) == 0x01) == true;
        bufferIndex += 2;
        if (extendedSecurity) {
            final int blobLength = readInt2(buffer, bufferIndex);
            bufferIndex += 2;
            blob = new byte[blobLength];
        }

        tree.tid = 123;

        // Create real request and response objects since they're not interfaces
        ServerMessageBlock request = new SmbComOpenAndX("testfile.txt", 0x01, 0, null);
        ServerMessageBlock response = new SmbComOpenAndXResponse();

        // Execute send
        tree.send(request, response);

        // Verify session.send was called and tid was set

class Smb2LeaseStateTest {

    @Test
    @DisplayName("Should define correct lease state constants")
    void testLeaseStateConstants() {
        assertEquals(0x00, Smb2LeaseState.SMB2_LEASE_NONE);
        assertEquals(0x01, Smb2LeaseState.SMB2_LEASE_READ_CACHING);
        assertEquals(0x02, Smb2LeaseState.SMB2_LEASE_HANDLE_CACHING);
        assertEquals(0x04, Smb2LeaseState.SMB2_LEASE_WRITE_CACHING);

            mockedCrypto.when(Crypto::getMD5).thenReturn(mockMd5);
            HMACT64 hmac = new HMACT64(TEST_KEY);
            hmac.engineUpdate((byte) 0x01);
            verify(mockMd5, times(1)).update((byte) 0x01);
        }
    }

    @Test
    void testEngineUpdateByteArray() throws NoSuchAlgorithmException {
        // Test engineUpdate(byte[] input, int offset, int len)

     * .
     */
    @Test
    public void testToBinary() {
        assertThat(BinaryConversionUtil.toBinary(null), nullValue());
        final byte[] b = { 0x00, 0x01 };
        assertThat(BinaryConversionUtil.toBinary(b), is(b));
        assertThat(BinaryConversionUtil.toBinary("hoge"), is("hoge".getBytes()));
    }

    /**
     * Test method for

    void byteArrayConstructor_malformedDER_throwsWrapped() {
        // Arrange: Truncated SEQUENCE (0x30 len=2 but only 1 byte of content)
        byte[] malformed = new byte[] { 0x30, 0x02, 0x01 };

        // Act + Assert
        PACDecodingException ex = assertThrows(PACDecodingException.class, () -> new KerberosApRequest(malformed, null));
        assertTrue(ex.getMessage().contains("Malformed Kerberos Ticket"));

        // Assert
        assertEquals(expectedFlags, queryPolicy.getFlags());
        // Binary check for individual flags
        assertEquals(0x03, queryPolicy.getFlags()); // 0x01 | 0x02 = 0x03
    }

    @Test
    void getOpnum_shouldReturnCorrectValue() {
        // Arrange
        short level = 1;

        }
    }

    /* --- flag handling -------------------------------- */
    @Test
    void testFlagSetAndUnset() {
        TestMessage m = new TestMessage();
        int FLAG_A = 0x01;
        int FLAG_B = 0x02;
        assertFalse(m.isFlagSet(FLAG_A));
        m.setFlag(FLAG_A);
        assertTrue(m.isFlagSet(FLAG_A));
        // unset correctly removes the flag
        m.unsetFlag(FLAG_A);