// (256) and thus requires fixLongPath to be correctly interpreted in I/O syscalls.
	veryLong := "l" + strings.Repeat("o", 500) + "ng"
	for _, test := range []struct{ in, want string }{
		// Test cases use word substitutions:
		//   * "long" is replaced with a very long pathname
		//   * "c:" or "C:" are replaced with the drive of the current directory (preserving case)
		//   * "cwd" is replaced with the current directory

		// Drive Absolute

        }
    }

    /**
     * Checks if the given value contains variable substitutions.
     *
     * @param value value to check
     * @return true if the value contains substitutions, false otherwise.
     */
    public static boolean hasUnresolvedSubstitutions(String value) {

            return ImmutableList.of(metadata.artifact("jar", "jar", null));
        } else {
            String type = metadata.getPackaging();
            // We were unable to resolve variable substitutions in the POM, so assume we're looking for a jar
            if (PomReader.hasUnresolvedSubstitutions(type)) {
                return ImmutableList.of(metadata.artifact("jar", "jar", null));
            } else {

        'yes'                   | "includeBuild('.')"
        // If substitutions for the root would be controllable (e.g. by the first include statement encountered) this would enable you to not have the ':subproject1' substitution
        // This documents the current behavior. It is unclear if this is a useful functionality to have.

        imlHasDependencies "buildB", "b1"
    }

    @ToBeFixedForConfigurationCache
    def "builds IDEA metadata with transitive substitutions"() {
        given:
        dependency "org.test:buildB:1.0"
        apiDependency buildB, "org.test:buildC:1.0"

        def buildC = singleProjectBuild("buildC") {
            buildFile << """

	st.advance(i)
	return &Clone{Base: a, Suffix: suffix}
}

// substitutions is the list of substitution candidates that may
// appear later in the string.
type substitutions []AST

// add adds a new substitution candidate.
func (subs *substitutions) add(a AST) {
	*subs = append(*subs, a)
}

// subAST maps standard substitution codes to the corresponding AST.
var subAST = map[byte]AST{

        def result = resolve(include('TEST(FILENAME, _NAME, ~)'))
        result.complete
        result.files.file as List == [header]
    }

    def "can chain token concatenations with parameter substitutions"() {
        given:
        def header = systemIncludeDir.createFile("test.h")

        macros << macro("FILENAME", '"test.h"')
        macroFunctions << macroFunction("TEST2(X)", "X")

	}

	return result
}

// ExpandContainerCommandOnlyStatic substitutes only static environment variable values from the
// container environment definitions. This does *not* include valueFrom substitutions.
// TODO: callers should use ExpandContainerCommandAndArgs with a fully resolved list of environment.
func ExpandContainerCommandOnlyStatic(containerCommand []string, envs []v1.EnvVar) (command []string) {

- Groovy has been updated to https://groovy-lang.org/changelogs/changelog-2.5.12.html[Groovy 2.5.12].

==== Dependency substitutions and variant aware dependency resolution

While adding support for expressing <<resolution_rules#sec:variant_aware_substitutions, variant support>> in dependency substitutions, a bug fix introduced a behaviour change that some builds may rely upon.

MINIO_IDENTITY_LDAP_USER_DN_SEARCH_FILTER*   (string)    Search filter to lookup user DN
```

The search filter must use the LDAP username to find the user DN. This is done via [variable substitution](#variable-substitution-in-configuration-strings).

The returned user's DN and their password are then verified with the LDAP server. The user DN may also be associated with an [access policy](#managing-usergroup-access-policy).