offset += 8;

        // Directory flags (4 bytes)
        int flags = 0;
        if (cacheScope == DirectoryCacheScope.RECURSIVE_TREE) {
            flags |= DIRECTORY_LEASE_FLAG_RECURSIVE;
        }
        if (notificationEnabled) {
            flags |= DIRECTORY_LEASE_FLAG_NOTIFICATIONS;
        }
        SMBUtil.writeInt4(flags, buffer, offset);
        offset += 4;

    }

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

    /**

    private final long offset;
    private final long length;
    private final int flags;

    /**
     * Constructs an SMB2 lock element with the specified parameters.
     *
     * @param offset the byte offset in the file where the lock begins
     * @param length the number of bytes to lock
     * @param flags the lock flags (combination of SMB2_LOCKFLAG_* constants)
     */

    private int flags;

    /**
     * Returns the flags currently in use for this message.
     *
     * @return An <code>int</code> containing the flags in use for this
     *         message.
     */
    public int getFlags() {
        return this.flags;
    }

    /**
     * Sets the flags for this message.
     *
     * @param flags
     *            The flags for this message.

    void testFlagChecking() {
        int flags = SecurityInfo.OWNER_SECURITY_INFO | SecurityInfo.DACL_SECURITY_INFO;

        // Test presence of flags
        assertTrue((flags & SecurityInfo.OWNER_SECURITY_INFO) != 0);
        assertTrue((flags & SecurityInfo.DACL_SECURITY_INFO) != 0);

        // Test absence of flags
        assertTrue((flags & SecurityInfo.GROUP_SECURITY_INFO) == 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");

        final String serverAddress;
        final int flags;
        final long timestamp;

        MockRegistration(String registrationId, String shareName, String serverAddress, int flags) {
            this.registrationId = registrationId;
            this.shareName = shareName;
            this.serverAddress = serverAddress;
            this.flags = flags;
            this.timestamp = System.currentTimeMillis();
        }

      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)

     *
     * @param config the configuration
     * @param compressionAlgorithms the supported compression algorithms
     * @param flags compression flags (reserved, should be 0)
     */
    public CompressionNegotiateContext(final Configuration config, final int[] compressionAlgorithms, final int flags) {

            // Check that no two flags overlap (except combined flags)
            for (int i = 0; i < flags.length; i++) {
                for (int j = i + 1; j < flags.length; j++) {
                    assertEquals(0, flags[i] & flags[j], String.format("Flags at index %d and %d should not overlap", i, j));
                }
            }
        }
    }