// Test each individual flag
        ace.flags = ACE.FLAGS_OBJECT_INHERIT;
        assertFalse(ace.isInherited());

        ace.flags = ACE.FLAGS_CONTAINER_INHERIT;
        assertFalse(ace.isInherited());

        ace.flags = ACE.FLAGS_NO_PROPAGATE;
        assertFalse(ace.isInherited());

        ace.flags = ACE.FLAGS_INHERIT_ONLY;
        assertFalse(ace.isInherited());

                        state = 0;

                        break;
                    case 20:
                        if (nctx == null) {
                            final boolean doSigning = (transport.flags2 & SmbConstants.FLAGS2_SECURITY_SIGNATURES) != 0;
                            nctx = new NtlmContext(auth, doSigning);
                        }

                        if (LogStream.level >= 4) {

     * @param flags
     *            The flags to apply to this message.
     * @param challenge
     *            The challenge from the domain controller/server.
     * @param target
     *            The authentication target.
     */
    public Type2Message(final CIFSContext tc, final int flags, final byte[] challenge, final String target) {
        setFlags(flags);
        setChallenge(challenge);

    }

    /**
     * Gets the registration flags.
     *
     * @return the registration flags
     */
    public int getFlags() {
        return flags;
    }

    /**
     * Sets the registration flags.
     *
     * @param flags the registration flags
     */
    public void setFlags(int flags) {
        this.flags = flags;
    }

    /**
     * Gets the context handle.

    protected boolean disablePlainTextPasswords = true;
    /** OEM encoding for non-Unicode operations */
    protected String oemEncoding = SmbConstants.DEFAULT_OEM_ENCODING;
    /** SMB flags2 field value */
    protected int flags2 = 0;
    /** SMB client capabilities */
    protected int capabilities = 0;
    /** Maximum number of concurrent SMB sessions */
    protected int sessionLimit = SmbConstants.DEFAULT_SSN_LIMIT;

        @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
        @DisplayName("Should encode multiple locks sequentially")

        parse(token);
    }

    /**
     * Gets the context flags indicating security capabilities
     * @return the context flags
     */
    public int getContextFlags() {
        return this.contextFlags;
    }

    /**
     * Sets the context flags indicating security capabilities
     * @param contextFlags the context flags to set
     */
    public void setContextFlags(final int contextFlags) {

        return (flags & flag) == flag;
    }

    /**
     * Unsets a specific flag
     * @param flag the flag to unset
     */
    public void unsetFlag(final int flag) {
        flags &= ~flag;
    }

    /**
     * Sets a specific flag
     * @param flag the flag to set
     */
    public void setFlag(final int flag) {
        flags |= flag;
    }

    /**

        for (int flag : new int[] { 0, 0xFF, 0x01, 0x80 }) {
            TestMessage m = new TestMessage();
            m.ptype = 0;
            m.flags = flag;

            NdrBuffer buf = new NdrBuffer(new byte[1024], 0);
            m.encode(buf);

            // Reset and skip to flags field
            buf.setIndex(3);
            assertEquals(flag, buf.dec_ndr_small());
        }
    }

    private void setNegotiatedFlags2(SmbComNegotiateResponse response, int flags2) {
        try {
            Field field = response.getClass().getDeclaredField("negotiatedFlags2");
            field.setAccessible(true);
            field.set(response, flags2);
        } catch (Exception e) {
            throw new RuntimeException("Failed to set negotiatedFlags2 field", e);
        }