@DisplayName("Should encode consistently with various flag values")
        @ValueSource(ints = { 0, 1, 2, 4, 16, 0xFF, 0xFFFF, 0xFFFFFF, 0x7FFFFFFF, -1 })
        void testEncodingWithVariousFlags(int flags) {
            lock = new Smb2Lock(1024L, 2048L, flags);
            int encoded = lock.encode(buffer, 0);

            assertEquals(24, encoded);
            assertEquals(flags, SMBUtil.readInt4(buffer, 16));
        }

     */
    @Test
    void testConstructor_CreateAndOpen() {
        int flags = SmbFile.O_CREAT;
        smbComOpenAndX = new SmbComOpenAndX(fileName, access, flags, andx);
        assertEquals(0x11, smbComOpenAndX.openFunction); // OPEN_FN_CREATE | OPEN_FN_OPEN
    }

    /**
     * Test constructor with no special flags.
     */
    @Test
    void testConstructor_OpenOnly() {
        int flags = 0;

        assertEquals(-1, negativeAvFlags.getFlags(), "Flags should be -1 for all FF bytes");
    }

    /**
     * Test constructor with integer flags.
     */
    @Test
    void testAvFlagsIntConstructor() {
        // Test with a positive integer
        int flags = 0x12345678;
        AvFlags avFlags = new AvFlags(flags);
        assertNotNull(avFlags, "AvFlags object should not be null");

    void testType1MessageWithFlags() {
        // Given
        int flags =
                NtlmFlags.NTLMSSP_NEGOTIATE_UNICODE | NtlmFlags.NTLMSSP_NEGOTIATE_NTLM | NtlmFlags.NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED;

        // When
        Type1Message type1 = new Type1Message(mockContext, flags, null, null);

        // Then
        // Note: Constructor sets default flags OR'd with provided flags

    }

    @DisplayName("Should handle various share flag combinations")
    @ParameterizedTest
    @MethodSource("provideFlagCombinations")
    void testShareFlagCombinations(int flags, boolean expectedDfs) throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = createValidResponseBuffer(0, flags, 0, 0);

        // When
        response.readBytesWireFormat(buffer, 0);

        assertFalse(message.getFlag(0b0100), "Flag 0b0100 should not be set.");
        assertFalse(message.getFlag(0b0001), "Flag 0b0001 should not be set.");

        message.setFlags(0); // No flags set
        assertFalse(message.getFlag(0b1000), "No flags should be set.");
    }

    @Test
    void testSetFlag() {
        // Test setting a flag
        message.setFlags(0);

    }

    /**
     * Gets the flags of this DCERPC message
     * @return the message flags
     */
    public int getFlags() {
        return flags;
    }

    /**
     * Check if a specific flag is set.
     * @param flag the flag to check
     * @return whether flag is set
     */
    public boolean isFlagSet(final int flag) {
        return (this.flags & flag) == flag;
    }

    /**
     * Remove flag

      TYPE_DATA -> readData(handler, length, flags, streamId)
      TYPE_HEADERS -> readHeaders(handler, length, flags, streamId)
      TYPE_PRIORITY -> readPriority(handler, length, flags, streamId)
      TYPE_RST_STREAM -> readRstStream(handler, length, flags, streamId)
      TYPE_SETTINGS -> readSettings(handler, length, flags, streamId)
      TYPE_PUSH_PROMISE -> readPushPromise(handler, length, flags, streamId)

        // These tests should be removed or replaced with actual constants
    }

    /**
     * Test individual FLAGS2 constants.
     */
    @Test
    @DisplayName("FLAGS2 individual constants are correct")
    void flags2ConstantsTest() {
        // Test individual flag values
        assertEquals(0x0001, SmbConstants.FLAGS2_LONG_FILENAMES);
        assertEquals(0x0002, SmbConstants.FLAGS2_EXTENDED_ATTRIBUTES);

        @DisplayName("Second constructor sets unshared based on flags")
        void secondCtorUnsharedFlagPath() throws Exception {
            // Arrange: include UNSHARED flag to exercise that branch
            int flags = SmbPipeResource.PIPE_TYPE_RDWR | SmbPipeResource.PIPE_TYPE_UNSHARED;

            // Act
            SmbNamedPipe pipe = new SmbNamedPipe("smb://server/IPC$/foo", flags, ctx());