(TaskSkippedResult)events.operations[0].result
    }

    private void runBuild(listener) {
        withConnection {
            ProjectConnection connection ->
                connection.newBuild().forTasks('noSourceTask').addProgressListener(listener, EnumSet.of(OperationType.TASK)).run()
        }
    }

        withConnection {
            def build = newBuild()
            build.setJvmArguments(NORMALIZED_BUILD_JVM_OPTS + "-Djava.io.tmpdir=${buildContext.getTmpDir().absolutePath}".toString())
            build.forTasks("help")
            build.run()
        }
    }

    private void runBuildViaCLI() {

            task baz {}
        """


        when:
        def listener = new ProblemProgressListener()
        withConnection { connection ->
            connection.newBuild()
                .forTasks(":ba")
                .addProgressListener(listener)
                .setStandardError(System.err)
                .setStandardOutput(System.out)
                .addArguments("--info")
                .run()
        }

        if (!targetVersionDetails.supportsRunTasksBeforeExecutingAction()) {
            if (operationParameters.getTasks() != null) {
                throw Exceptions.unsupportedFeature("forTasks() method on BuildActionExecuter", targetVersionDetails.getVersion(), "3.5");
            }
        }
    }

        withConnection {
            ProjectConnection connection ->
                connection.newBuild()
                    .addProgressListener(events, [OperationType.TASK] as Set)
                    .forTasks("build")
                    .run()
        }

        then:
        events.tasks.size() == events.operations.size()
        events.operation("Task :buildSrc:a:compileJava")

        when:
        try {
            withConnection {
                ProjectConnection connection ->
                    connection.newBuild()
                        .forTasks('nested2')
                        .addProgressListener(events)
                        .run()
            }
        } catch (ListenerFailedException e) {
            caughtException = e.cause
        }

        when:
        withConnection {
            ProjectConnection connection ->
                connection.newBuild()
                    .setStandardOutput(output)
                    .forTasks("help")
                    .run()
        }

        then:
        listenersWereCalled()
    }

    void listenersWereCalled() {
        def result = output.toString()

                }
            }
        """
    }

    def runTestAndCollectProgressEvents() {
        withConnection { ProjectConnection connection ->
            connection.newBuild().forTasks('test').addProgressListener({ event -> progressEvents << event } as org.gradle.tooling.events.ProgressListener).run()
        }
    }

    def getTestEvents() {
        getProgressEvents(TestFinishEvent)
    }

        given:
        goodCode()
        def sync = server.expectAndBlock('sync')

        when:
        def result = []
        withConnection { ProjectConnection connection ->
            connection.newBuild().forTasks('test').addProgressListener({ ProgressEvent event ->
                result << event
                if (!killed) {
                    sync.waitForAllPendingCalls()
                    sync.releaseAll()

            // TestKit builds that use debug will set this to true
            it.embedded(true)
        }

        // Run the build
        withConnection { c ->
            c.newBuild().forTasks("myTask").run()
        }
    }