@Test
        @DisplayName("isFlagSet should correctly identify set flags")
        void testIsFlagSet() {
            // Test when flag is not set
            message.flags = 0;
            assertFalse(message.isFlagSet(DcerpcConstants.RPC_C_PF_BROADCAST));

            // Test when flag is set
            message.flags = DcerpcConstants.RPC_C_PF_BROADCAST;

        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) {

    val result = mutableListOf<InetAddress>()

    val buf = Buffer()
    buf.write(byteString)
    buf.readShort() // query id

    val flags = buf.readShort().toInt() and 0xffff
    require(flags shr 15 != 0) { "not a response" }

    val responseCode = flags and 0xf

    if (responseCode == NXDOMAIN) {
      throw UnknownHostException("$hostname: NXDOMAIN")
    } else if (responseCode == SERVFAIL) {

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

    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 flags;
    }

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

        }
    }

    /**
     * Convert RDMA access flags to DiSNI flags
     *
     * @param access RDMA access flags
     * @return DiSNI access flags
     */
    @SuppressWarnings("unused")
    private int convertAccessFlags(EnumSet<RdmaAccess> access) {
        int flags = 0;

        // In real implementation, this would convert to DiSNI constants:

    // flags is NOT the same as flags member

    /**
     * Constructs an Open AndX request.
     *
     * @param config the configuration
     * @param fileName the name of the file to open
     * @param access the desired access mode
     * @param shareAccess the share access mode
     * @param flags the open flags
     * @param fileAttributes the file attributes

        boolean end = false;
        int flags;
        String charset;
        if (lmResponseOffset < pos + 12 || ntResponseOffset < pos + 12 || domainOffset < pos + 12 || userOffset < pos + 12
                || workstationOffset < pos + 12) {
            // no room for SK/Flags
            flags = NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_OEM;
            setFlags(flags);
            charset = getOEMEncoding();

        return timeout100Ns / 10000L;
    }

    /**
     * Get the flags
     * @return the flags
     */
    public int getFlags() {
        return flags;
    }

    /**
     * Check if this is a persistent handle
     * @return true if persistent
     */
    public boolean isPersistent() {
        return (flags & Smb2HandleCapabilities.SMB2_DHANDLE_FLAG_PERSISTENT) != 0;
    }

    /**

     * @param user the username
     * @param workstation the workstation name
     * @param flags the flags to use for the Type-3 message
     */
    public Type3Message(final Type2Message type2, final String password, final String domain, final String user, String workstation,
            final int flags) {
        setFlags(flags | getDefaultFlags(type2));
        if (workstation == null) {