int flags = NegTokenInit.REPLAY_DETECTION | NegTokenInit.SEQUENCE_CHECKING;
        byte[] mic = new byte[] { 0x00, 0x0A, (byte) 0xFF };

        NegTokenInit init = new NegTokenInit(mechs, flags, null, mic);
        String s = init.toString();

        assertTrue(s.contains("flags=" + flags), "toString should include flags");

     *
     * @param flags The flags to apply to this message.
     * @param suppliedDomain The supplied authentication domain.
     * @param suppliedWorkstation The supplied workstation name.
     */
    public Type1Message(final int flags, final String suppliedDomain, String suppliedWorkstation) {
        setFlags(getDefaultFlags() | flags);
        setSuppliedDomain(suppliedDomain);

    private static final int BATCH_LIMIT = Config.getInt("jcifs.smb1.smb.client.OpenAndX.ReadAndX", 1);

    int flags, desiredAccess, searchAttributes, fileAttributes, creationTime, openFunction, allocationSize;

    // flags is NOT the same as flags member

    SmbComOpenAndX(final String fileName, final int access, final int flags, final ServerMessageBlock andx) {
        super(andx);
        this.path = fileName;

	if err != nil {
		t.Fatal(err)
	}
	for i, test := range utf8Tests {
		flags := r.File[i].Flags
		if flags != test.flags {
			t.Errorf("CreateHeader(name=%q comment=%q nonUTF8=%v): flags=%#x, want %#x", test.name, test.comment, test.nonUTF8, flags, test.flags)
		}
	}
}

func TestWriterTime(t *testing.T) {
	var buf bytes.Buffer
	h := &FileHeader{

    }

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

        }
    }

    void send(final ServerMessageBlock request, final ServerMessageBlock response) throws SmbException {

        connect(); /* must negotiate before we can test flags2, useUnicode, etc */

        request.flags2 |= flags2;
        request.useUnicode = useUnicode;
        request.response = response; /* needed by sign */
        if (request.digest == null) {

        try {
            int flags = getFlags();
            int size = 8 * 4 + ((flags & NTLMSSP_NEGOTIATE_VERSION) != 0 ? 8 : 0);

            byte[] domain = {};
            final String suppliedDomainString = getSuppliedDomain();
            if ((flags & NTLMSSP_NEGOTIATE_VERSION) == 0 && suppliedDomainString != null && suppliedDomainString.length() != 0) {
                flags |= NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED;

     * @param length the number of bytes to lock
     * @param flags the lock flags (combination of SMB2_LOCKFLAG_* constants)
     */
    public Smb2Lock(final long offset, final long length, final int flags) {
        this.offset = offset;
        this.length = length;
        this.flags = flags;

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */
    @Override

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

        /**
         * Checks if this is an IPv4 address.
         *
         * @return true if IPv4
         */
        public boolean isIPv4() {
            return (flags & IPV4) != 0;
        }

        /**

        // Status (4 bytes) - success
        buffer[5] = 0x00;
        buffer[6] = 0x00;
        buffer[7] = 0x00;
        buffer[8] = 0x00;

        // Flags
        buffer[9] = 0x00;

        // Flags2 (2 bytes)
        buffer[10] = 0x00;
        buffer[11] = 0x00;

        // Process ID High (2 bytes)
        buffer[12] = 0x00;
        buffer[13] = 0x00;