* @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 lease flags for this V2 request
     * @return the lease flags
     */
    public int getLeaseFlags() {
        return leaseFlags;
    }

    /**
     * Sets the lease flags for this V2 request
     * @param leaseFlags the lease flags to set
     */
    public void setLeaseFlags(int leaseFlags) {
        this.leaseFlags = leaseFlags;
    }

    }

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

        assertTrue(req instanceof ServerMessageBlock2);
    }

    @Test
    @DisplayName("Should set notify flags correctly")
    void testSetNotifyFlags() throws Exception {
        // Given
        int flags = Smb2ChangeNotifyRequest.SMB2_WATCH_TREE;

        // When
        request.setNotifyFlags(flags);

        // Then
        Field notifyFlagsField = Smb2ChangeNotifyRequest.class.getDeclaredField("notifyFlags");

    void testGetAndSetFlags() {
        // Test setting and getting flags
        int testFlags = 0x12345678;
        message.setFlags(testFlags);
        assertEquals(testFlags, message.getFlags(), "Flags should be set and retrieved correctly.");
    }

    @Test
    void testGetFlag() {
        // Test getting individual flags
        message.setFlags(0b1010); // Set flags: 8 (0x8) and 2 (0x2)

        @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")

        @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());

        return new Smb2IoctlResponse(tc.getConfig(), this.outputBuffer, this.controlCode);
    }

    /**
     * Set the IOCTL flags
     * @param flags the flags to set
     */
    public void setFlags(final int flags) {
        this.flags = flags;
    }

    /**
     * Set the maximum input response size
     * @param maxInputResponse the maxInputResponse to set
     */

    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

	skip := func(oi ObjectInfo) (ok bool) {
		if r.Flags.Filter.OlderThan > 0 && time.Since(oi.ModTime) < r.Flags.Filter.OlderThan.D() {
			// skip all objects that are newer than specified older duration
			return true
		}

		if r.Flags.Filter.NewerThan > 0 && time.Since(oi.ModTime) >= r.Flags.Filter.NewerThan.D() {