// include directories: look in source dir, then -I directories.
		includes:        append([]string{filepath.Dir(name)}, flags.I...),
		beginningOfLine: true,
		macros:          predefine(flags.D),
	}
}

// predefine installs the macros set by the -D flag on the command line.
func predefine(defines flags.MultiFlag) map[string]*Macro {
	macros := make(map[string]*Macro)
	for _, name := range defines {
		value := "1"

	# endpoint: ENDPOINT
	# credentials:
	#   accessKey: ACCESS-KEY
	#   secretKey: SECRET-KEY
	#   sessionToken: SESSION-TOKEN # Available when rotating credentials are used

  # optional flags based filtering criteria
  # for all source objects
  flags:
	filter:
	  newerThan: "7d" # match objects newer than this value (e.g. 7d10h31s)
	  olderThan: "7d" # match objects older than this value (e.g. 7d10h31s)

     * @return the granted lease state
     */
    public int getLeaseState() {
        return leaseState;
    }

    /**
     * Gets the lease flags from the V2 server response
     * @return the lease flags
     */
    public int getLeaseFlags() {
        return leaseFlags;
    }

    /**
     * Gets the parent lease key from the V2 response
     * @return the parent lease key

    /**
     * Constructs a ValidateNegotiateInfo request
     *
     * @param capabilities
     *            the client capabilities flags
     * @param clientGuid
     *            the client GUID
     * @param securityMode
     *            the security mode flags
     * @param dialects
     *            the SMB dialects supported by the client
     */

            assertEquals(100L, t.delay, "Default delay should be 100");
        }

        @Test
        @DisplayName("Multiple flags are parsed correctly")
        void multipleFlags() {
            TestLocking t = new TestLocking();

            // Parse multiple flags
            String[] args = { "-t", "3", "-i", "7", "-d", "200", "smb://test/file.txt" };
            for (int ai = 0; ai < args.length; ai++) {

// license that can be found in the LICENSE file.

package lex

import (
	"go/build/constraint"
	"io"
	"os"
	"strings"
	"text/scanner"
	"unicode"

	"cmd/asm/internal/flags"
	"cmd/internal/objabi"
	"cmd/internal/src"
)

// A Tokenizer is a simple wrapping of text/scanner.Scanner, configured
// for our purposes and made a TokenReader. It forms the lowest level,

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

        src[srcIndex + 16] = 0x00; // hex code
        src[srcIndex + 17] = 0x04; // flags: active

        // Second name entry (18 bytes)
        String name2 = "DOMAIN          ";
        System.arraycopy(name2.getBytes("US-ASCII"), 0, src, srcIndex + 19, 16);
        src[srcIndex + 34] = 0x00; // hex code
        src[srcIndex + 35] = (byte) 0x84; // flags: group, active

        // Third name entry (18 bytes) - matching queryAddress

        // Verify that the constructor correctly sets ptype and flags
        // These values are inherited from LsarClose, but MsrpcLsarClose sets them in its constructor
        assertEquals(0, msrpcLsarClose.getPtype(), "ptype should be 0");
        assertEquals(DcerpcConstants.DCERPC_FIRST_FRAG | DcerpcConstants.DCERPC_LAST_FRAG, msrpcLsarClose.getFlags(),
                "flags should be DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");

    // RPC_C_PF_ flags (packet flags)
    /**
     * Broadcast packet flag
     */
    int RPC_C_PF_BROADCAST = 0x01;
    /**
     * No fragmentation packet flag
     */
    int RPC_C_PF_NO_FRAGMENT = 0x02;
    /**
     * Maybe semantics packet flag
     */
    int RPC_C_PF_MAYBE = 0x04;
    /**
     * Idempotent operation packet flag
     */
    int RPC_C_PF_IDEMPOTENT = 0x08;