withConnection { connection ->
            connection.newBuild().forTasks('help').run()
        }

        file("gradle.properties").writeProperties("org.gradle.java.home": jdk17.javaHome.absolutePath)
        withConnection { connection ->
            connection.newBuild().forTasks('help').run()
        }
    }

        def models = runPhasedBuildAction(new FetchPartialCustomModelForEachProject(), new FetchCustomModelForEachProject()) {
            // Empty list means "run tasks defined by build logic or default tasks"
            forTasks([])
        }

        then:
        def messages = models.left
        messages.size() == 2
        messages[0] == "It works from project :"
        messages[1] == "It works from project :a"

        """
    }

    def runTask() {
        def listener = new ProblemProgressListener()
        withConnection { connection ->
            connection.newBuild().forTasks('reportProblem')
                .addProgressListener(listener)
                .run()
        }
        return listener.problems.collect { it.descriptor }
    }


    @TargetGradleVersion("=8.3")

        withConnection { ProjectConnection connection ->
            def build = connection.newBuild()
            build.standardOutput = output
            build.colorOutput = true
            build.forTasks("log")
            build.run()
        }

        then:
        output.toString().contains(escapeHeader)

        and:
        !stdOutAndErr.stdOut.contains(escapeHeader)

                return model;
            }
        }, new ResultHandlerAdapter<T>(handler));
    }

    @Override
    public DefaultModelBuilder<T> forTasks(String... tasks) {
        // only set a non-null task list on the operationParamsBuilder if at least one task has been given to this method,

        toolingApi.withConnection { ProjectConnection connection ->
            def buildAction = connection.action(new LoadCompositeModel(GradleProject))
            collectOutputs(buildAction)
            buildAction.forTasks([':other-build:sub:doSomething'])
            buildAction.run()
        }

        then:
        stdout.toString().contains("do something")
    }

        buildFile getProblemReportTaskString(taskActionMethodBody)
    }

    def runTask() {
        def listener = new ProblemProgressListener()
        withConnection { connection ->
            connection.newBuild().forTasks('reportProblem')
                .addProgressListener(listener)
                .run()
        }
        return listener.problems
    }

    def "Failing executions produce problems"() {
        setup:

        when:
        def events = ProgressEvents.create()
        withConnection { ProjectConnection connection ->
            def build = connection.newBuild()
            collectOutputs(build)
            build.forTasks("resolve")
            build.addProgressListener(events, OperationType.FILE_DOWNLOAD)
                .run()
        }

        then:
        thrown(BuildException)

        events.operations.size() >= 4

        toolingApi.withConnection { ProjectConnection connection ->
            ModelBuilder<GradleProject> modelBuilder = connection.model(GradleProject.class)
            collectOutputs(modelBuilder)
            modelBuilder.forTasks([':other-build:sub:doSomething'])
            modelBuilder.get()
        }

        then:
        stdout.toString().contains("do something")
    }

    }

    private void runCacheableBuild(listener) {
        withConnection {
            ProjectConnection connection ->
                connection.newBuild().withArguments("--build-cache").forTasks('cacheable').addProgressListener(listener, EnumSet.of(OperationType.TASK)).run()
        }
    }