when:
        def events = runBuild("compileJava")

        then:
        def operation = events.operation("Task :compileJava")
        operation.assertIsTask()
        operation.result instanceof TaskSuccessResult
        !(operation.result instanceof JavaCompileTaskOperationResult)
    }

    private ProgressEvents runBuild(task) {
        ProgressEvents events = ProgressEvents.create()

    }

    @Override
    public void scheduleAndRunTasks(@Nullable EntryTaskSelector selector) {
        runBuild(() -> workController.scheduleAndRunRequestedTasks(selector));
    }

    @Override
    public <T> T fromBuildModel(boolean runTasks, BuildTreeModelAction<? extends T> action) {
        return runBuild(() -> {
            modelCreator.beforeTasks(action);
            if (runTasks && isEligibleToRunTasks()) {

        def taskEvents = ProgressEvents.create()
        runBuild(taskEvents)
        then:
        skippedTaskResult(taskEvents).skipMessage == "NO-SOURCE"
    }

    private TaskSkippedResult skippedTaskResult(ProgressEvents events) {
        events.operations.size() == 1
        (TaskSkippedResult)events.operations[0].result
    }

    private void runBuild(listener) {
        withConnection {

                instant.resultAvailable
                handler.onComplete(null)
            }
        }

        when:
        operation.runBuild {
            launcher.run()
        }

        then:
        operation.runBuild.end > instant.resultAvailable
    }

    def "run() blocks until build fails"() {
        RuntimeException failure = new RuntimeException()

        given:

            ProblemListener.createAndRegister(modelBuilder);
            modelBuilder.get();
        }
    }

    public void runBuild() {
        try (ProjectConnection connection = createGradleConnection()) {
            // Load the project
            BuildLauncher buildLauncher = connection.newBuild();
            buildLauncher.addArguments("--quiet");

        int sleepPeriod = quietPeriodMillis * 2
        buildFile << buildLogicForEndOfBuildWait(sleepPeriod)
    }

    @Override
    protected ExecutionResult succeeds(String... tasks) {
        runBuild(tasks)
        waitForBuild()
        throwOnBuildFailure()
        result
    }

    protected ExecutionResult buildTriggeredAndSucceeded() {
        if (!gradle.isRunning()) {

    def "client can receive appropriate logging and progress events for subsequent builds"() {
        when:
        def javaSrcFile = sourceDir.file("Thing.java") << 'public class Thing {}'

        then:
        runBuild {
            succeeds()
            receivedBuildEvents()
            waitBeforeModification javaSrcFile
            javaSrcFile.setText('public class Thing { public static final int FOO = 1; }')
            succeeds()

    def setup() {
        fixture.writeToProject(projectDir)
        buildTimeout = 30
    }

    def "deployment is stopped when continuous build is cancelled" () {
        when:
        runBuild(["runDeployment"]) {
            succeeds()
            def key = fixture.keyFile.text
            fixture.assertDeploymentIsRunning(key)

            waitBeforeModification fixture.triggerFile

            projectConnection = it
            try {
                it.with(cl)
            } finally {
                projectConnection = null
            }
        }
    }

    public <T> T runBuild(List<String> tasks = ["build"], Closure<T> underBuild) {
        if (projectConnection) {
            buildResult = new TestResultHandler()

            cancellationTokenSource.withCancellation { CancellationToken token ->

        tweakProject()

        when:
        run()

        then:
        outputContains("gradle-tooling-api-")
        outputContains("src/main/java")
    }

    @UsesSample('toolingApi/runBuild/groovy')
    def "can use tooling API to run tasks"() {
        tweakProject()

        when:
        run()

        then:
        outputContains("Welcome to Gradle")
    }