* The intended use is to provide workers for the {@code buildScan.background} callbacks.
     * The jobs will be complete before {@link GradleEnterprisePluginEndOfBuildListener#buildFinished(GradleEnterprisePluginEndOfBuildListener.BuildResult)} is called.
     * <p>
     * The job may be rejected if the build is already finishing and the executor is being shut down.

     * @throws InternalBuildCancelledException When the operation was cancelled before it could complete.
     * @throws IllegalStateException When this connection has been stopped.
     */
    BuildResult<?> run(InternalPhasedAction internalPhasedAction,
                       PhasedActionResultListener listener,
                       InternalCancellationToken cancellationToken,

            reporter.report(results)
        }
        return results
    }

    void runAllSpecifications(R results) {
        specs.each {
            def operations = results.buildResult(it.displayInfo)
            experimentRunner.run(testId, it, operations)
        }
    }

    protected static String determineChannel() {
        ResultsStoreHelper.determineChannel()
    }

            return results.getVcsCommits();
        }

        @Override
        public List<MeasuredOperationList> getScenarios() {
            return builds.stream().map(specification -> results.buildResult(specification.getDisplayName())).collect(Collectors.toList());
        }

        @Override
        public String getOperatingSystem() {
            return results.getOperatingSystem();
        }

        method              | params
        "settingsEvaluated" | "Settings settings"
        "projectsLoaded"    | "Gradle gradle"
        "projectsEvaluated" | "Gradle gradle"
        "buildFinished"     | "BuildResult result"
    }

    @UnsupportedWithConfigurationCache
    def "produces reasonable error message when build fails and Gradle.buildFinished closure also fails"() {
        buildFile << """

            .forwardStdOutput(standardOutput)
            .forwardStdError(standardError)
            .buildAndFail()

        then:
        def t = thrown UnexpectedBuildSuccess
        def result = t.buildResult
        result.output.findAll(OUT).size() == 1
        result.output.findAll(ERR).size() == 1
        standardOutput.toString().findAll(OUT).size() == 1
        standardError.toString().findAll(OUT).size() == 0

                        build().output,
                        containsString("Ack!"))
                }

                private
                fun build(vararg arguments: String): BuildResult =
                    GradleRunner
                        .create()
                        .withProjectDir(temporaryFolder.root)
                        .withPluginClasspath()

        buildOperationNotificationListenerRegistrar.register(pluginService.getBuildOperationNotificationListener());
    }

    private class DefaultDevelocityPluginResult implements GradleEnterprisePluginEndOfBuildListener.BuildResult {
        private final Throwable buildFailure;

        public DefaultDevelocityPluginResult(@Nullable Throwable buildFailure) {
            this.buildFailure = buildFailure;
        }

        @Nullable

import static org.gradle.testkit.runner.TaskOutcome.SKIPPED
import static org.gradle.testkit.runner.TaskOutcome.SUCCESS
import static org.gradle.testkit.runner.TaskOutcome.UP_TO_DATE

/**
 * Tests more intricate aspects of the BuildResult object
 */
@InspectsExecutedTasks
@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = "Test causes builds to hang")
class GradleRunnerResultIntegrationTest extends BaseGradleRunnerIntegrationTest {

            }
        }

        when:
        def results = runner.run()

        then:
        def withoutResults = buildBaselineResults(results, WITHOUT_PLUGIN_LABEL)
        def withResults = results.buildResult(WITH_PLUGIN_LABEL)
        def speedStats = withoutResults.getSpeedStatsAgainst(withResults.name, withResults)
        println(speedStats)

        where: