then:
        output.contains "the name: foobar"
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects, evaluationDependsOn")
    def "shows deprecation warning when calling Project#afterEvaluate(Closure) after the project was evaluated"() {
        buildFile << '''
            allprojects { p ->
                println "[1] Adding afterEvaluate for $p.name"
                p.afterEvaluate {

    def singleProjectBuild(String projectName, @DelegatesTo(value = BuildTestFile, strategy = Closure.DELEGATE_FIRST) Closure cl = {}) {
        buildTestFixture.singleProjectBuild(projectName, cl)
    }

    def multiProjectBuild(String projectName, List<String> subprojects, @DelegatesTo(value = BuildTestFile, strategy = Closure.DELEGATE_FIRST) Closure cl = {}) {
        multiProjectBuild(projectName, subprojects, CompiledLanguage.JAVA, cl)
    }

        }

        then:
        hasNoSystemProperty('java.io.tmpdir', customTmpDir)
    }

    private void runTask(@DelegatesTo(value = BuildLauncher, strategy = Closure.DELEGATE_ONLY) Closure<?> launcherSpec = {}) {
        withConnection {
            def launcher = newBuild().forTasks('printSystemProperty')
            launcherSpec.delegate = launcher
            launcherSpec()

                .assertHasFileName("Build file '$buildFile'")
                .assertHasLineNumber(4)
    }

    @Issue("https://github.com/gradle/gradle/issues/14984")
    def "referencing a non-existing closure-taking method yields a helpful error message"() {
        buildFile << """
            plugins {
                id("java")
            }

            java {
                toolchains { // should be toolchain

eq:
	MOVV	$1, R4
	RET

// memequal_varlen(a, b unsafe.Pointer) bool
TEXT runtime·memequal_varlen<ABIInternal>(SB),NOSPLIT,$40-17
	BEQ	R4, R5, eq
	MOVV	8(REGCTXT), R6    // compiler stores size at offset 8 in the closure
	MOVV	R4, 8(R3)
	MOVV	R5, 16(R3)
	MOVV	R6, 24(R3)
	JAL	runtime·memequal(SB)
	MOVBU	32(R3), R4
	RET
eq:
	MOVV	$1, R4

    api(project(":problems-api"))
    api(project(":service-provider"))
    api(project(":tooling-api"))

    runtimeOnly(project(":composite-builds"))
    runtimeOnly(libs.groovy) // for 'Closure'

    testCompileOnly(project(":toolchains-jvm")) {
        because("JavaLauncher is required for mocking Test.")
    }
    testImplementation(project(":file-collections"))
    testImplementation(project(":platform-jvm"))

        expect:
        succeeds 'buildEnvironment'
        outputContains('org.apache.logging.log4j:log4j-core:{require 2.17.1; reject [2.0, 2.17.1)} -> 3.1.0 (c)')
    }

    def "can use configuration closure in buildscript block"() {
        buildFile << """
            buildscript {
                configurations {
                    foo {
                        attributes {

        BuildEnvironment env
        withConnection {
            def builder = it.model(BuildEnvironment)
            config(builder)
            env = builder.get()
        }
        env
    }

    private String runBuild(@ClosureParams(value = SimpleType, options = ["org.gradle.tooling.BuildLauncher"]) Closure config) {

        return args.length == 1 &&
            (args[0] instanceof Closure || args[0] instanceof Action) &&
            extensionsStorage.hasExtension(name);
    }

    private Object configureExtension(String name, Object[] args) {
        Action<Object> action;
        if (args[0] instanceof Closure) {
            action = ConfigureUtil.configureUsing(Cast.uncheckedCast(args[0]));
        } else {

    return nullptr;
  }

  bool GetCurrentThreadName(tsl::string* name) override { return false; }

  void SchedClosure(absl::AnyInvocable<void()> closure) override {}

  void SchedClosureAfter(int64_t micros,
                         absl::AnyInvocable<void()> closure) override {}

  absl::Status LoadDynamicLibrary(const char* library_filename,
                                  void** handle) override {