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();
        }

 * limitations under the License.
 */

package org.gradle.internal.cc.impl

import groovy.lang.Closure
import org.gradle.BuildListener
import org.gradle.BuildResult
import org.gradle.api.Action
import org.gradle.api.Project
import org.gradle.api.ProjectEvaluationListener
import org.gradle.api.ProjectState
import org.gradle.api.initialization.IncludedBuild

        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 {

        result.value.result.serializedModel.empty
        result.value.failure == null
        result.value.exception == null

        def buildResult = BuildActionResult.of(new SerializedPayload("header", ["hi".bytes]))
        def message2 = new Success(buildResult)
        def result2 = serialize(message2, serializer)
        result2 instanceof Success
        result2.value instanceof BuildActionResult

            }
        }

        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: