}
    }

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

	if err != nil {
		err = msgp.WrapError(err, "LimitInBytesPerSecond")
		return
	}
	// write "CurrentBandwidthInBytesPerSecond"
	err = en.Append(0xd9, 0x20, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x42, 0x61, 0x6e, 0x64, 0x77, 0x69, 0x64, 0x74, 0x68, 0x49, 0x6e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x50, 0x65, 0x72, 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64)
	if err != nil {
		return
	}
	err = en.WriteFloat64(z.CurrentBandwidthInBytesPerSecond)

        // First decode
        byte[] buffer1 = new byte[28];
        Arrays.fill(buffer1, 0, 24, (byte) 0x11);

        int bytesConsumed1 = response.decode(buffer1, 0, 28);
        assertEquals(28, bytesConsumed1);

        byte[] resumeKey1 = response.getResumeKey();
        assertNotNull(resumeKey1);
        assertEquals((byte) 0x11, resumeKey1[0]);

        // Second decode - should overwrite

                // 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.
     */
    @Test
    @DisplayName("edge: writeParameterWordsWireFormat with lastWriteTime=0")

    class ToStringTests {

        @Test
        @DisplayName("toString with valid data produces expected format")
        void testToStringWithValidData() {
            byte[] challenge = new byte[] { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0xFF };
            UniAddress dc = mock(UniAddress.class);
            when(dc.toString()).thenReturn("SERVER123");

            NtlmChallenge nc = new NtlmChallenge(challenge, dc);

        // Test successful reading of 6 bytes from the input stream.
        // The content of these bytes is not critical for this test, only that 6 bytes are read.
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }; // Sample 6 bytes
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        SessionRetargetResponsePacket packet = new SessionRetargetResponsePacket();

            SMBUtil.writeInt8(500, buffer1, 48);
            SMBUtil.writeInt4(0x01, buffer1, 56);

            response.readBytesWireFormat(buffer1, 0);

            assertEquals(1, response.getCloseFlags());
            assertEquals(1000, response.getAllocationSize());
            assertEquals(500, response.getEndOfFile());
            assertEquals(0x01, response.getFileAttributes());

            // Second read with different values

public class AvFlagsTest {

    /**
     * Test constructor with raw bytes.
     */
    @Test
    void testAvFlagsByteArrayConstructor() {
        // Test with a positive integer
        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");

    private LeaseV1CreateContextRequest leaseContext;
    private Smb2LeaseKey testKey;
    private int testState;

    @BeforeEach
    void setUp() {
        byte[] keyBytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };
        testKey = new Smb2LeaseKey(keyBytes);
        testState = Smb2LeaseState.SMB2_LEASE_READ_WRITE;

    @Test
    @DisplayName("Test constructor initialization with command and subcommand")
    void testConstructorWithCommandAndSubcommand() {
        byte command = (byte) 0x25;
        byte subcommand = (byte) 0x01;
        TestSmbComTransactionResponse resp = new TestSmbComTransactionResponse(mockConfig, command, subcommand);
        assertNotNull(resp);
        assertEquals(command, resp.getCommand());