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

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

                }
            }
        """
    }

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

    def getTestEvents() {
        getProgressEvents(TestFinishEvent)
    }

                .buildFinished(new ParameterizedLoadCompositeEclipseModels(workspace, EclipseProject), buildFinishedHandler)
                .build()
                .setStandardOutput(out)
                .forTasks()
                .run()
        }

        def eclipseProjects = buildFinishedHandler.result

        then:
        def b1Model = eclipseProjects.collectMany { collectProjects(it) }.find { it.name == "b1" }

    }

    private ProgressEvents runBuild(task) {
        ProgressEvents events = ProgressEvents.create()
        withConnection {
            newBuild()
                .forTasks(task)
                .setStandardOutput(System.out)
                .addProgressListener(events, OperationType.TASK)
                .run()
        }
        events
    }

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

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

        runDumpTaskWithTapi()

        then:
        agentWasNotApplied()
    }

    private void runDumpTaskWithTapi() {
        withConnection {
            buildOutput = withBuild {
                it.forTasks("hello")
            }.stdout.toString()
        }
    }

    private void agentWasApplied() {
        agentStatusWas(true)
    }

    private void agentWasNotApplied() {
        agentStatusWas(false)

        result.assertTasksExecutedInOrder(":api:foo", ":impl:bar")
    }

    def "supports buildSrc"() {
        file("buildSrc/src/main/java/FooTask.java") << """
            import org.gradle.api.DefaultTask;
            import org.gradle.api.tasks.TaskAction;

            public class FooTask extends DefaultTask {
                @TaskAction public void logStuff(){

    }

    private void runBuild(String... tasks) {
        withConnection {
            ProjectConnection connection ->
                connection.newBuild()
                    .forTasks(tasks)
                    .addProgressListener(events, EnumSet.of(OperationType.TASK))
                    .run()
        }
    }

    private Set<? extends OperationDescriptor> tasks(String... paths) {

    }

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

        '''.stripIndent()

        TestOutputStream stdout = new TestOutputStream()

        when:
        withConnection { connection -> connection.newBuild().setStandardOutput(stdout).forTasks('hello').run() }
        String output = stdout.toString()

        then:
        output.contains('system_property_available in buildSrc:                 true')