buildResults[buildInfo] = buildResult
        }
        return buildResult
    }

    public Set<BuildDisplayInfo> getBuilds() {
        buildResults.keySet()
    }

    MeasuredOperationList buildResult(String displayName) {
        def matches = builds.findAll { it.displayName == displayName }
        if (matches.empty) {

        ModelIdentifier someModelIdentifier = Mock(ModelIdentifier)
        1 * mapping.getModelIdentifierFromModelType(SomeModel.class) >> someModelIdentifier
        BuildResult buildResult = Mock(BuildResult)
        ViewBuilder<SomeModel> viewBuilder = Mock()
        ConsumerOperationParameters operationParameters = Stub(ConsumerOperationParameters)

        when:

            .withArguments(":binary-compatibility:checkBinaryCompatibility", "-s")

        val (buildResult, failure) = try {
            runner.build()!! to null
        } catch (ex: UnexpectedBuildFailure) {
            ex.buildResult!! to ex
        }

        println(buildResult.output)

        val richReportFile = inputBuildDir.resolve("binary-compatibility/build/japi/japi.html").apply {

 */
public interface GradleEnterprisePluginEndOfBuildListener {

    interface BuildResult {
        @Nullable
        Throwable getFailure();

        Collection<Problem> getProblems();

        Collection<Problem> getProblemsFor(Throwable failure);
    }

    void buildFinished(BuildResult buildResult);

                                return { $GradleEnterprisePluginEndOfBuildListener.BuildResult.name buildResult ->
                                    println "${propertyPrefix}.endOfBuild.buildResult.failure = \$buildResult.failure"
                                    println "${propertyPrefix}.endOfBuild.buildResult.problems = \${buildResult.problems.size()}"

        } finally {
            lock.unlock();
        }
    }

    public void buildFinished(BuildResult buildResult) {
        lock.lock();
        try {
            pendingChanges.changesIncorporated();
            if (!pendingChanges.hasRemainingChanges()) {
                Throwable failure = buildResult.getFailure();
                for (RegisteredDeployment deployment : deployments.values()) {

        output.contains("Virtual file system retains information")
    }

    private static void assertFileSystemWatchingEnabled(BuildResult result) {
        assert fileSystemWatchingEnabled(result.output)
    }

    private static void assertFileSystemWatchingDisabled(BuildResult result) {
        assert !fileSystemWatchingEnabled(result.output)
    }

            testKitDaemons().killAll()
        }
    }

    ExecutionResult execResult(BuildResult buildResult) {
        OutputScrapingExecutionResult.from(buildResult.output, buildResult.output)
    }

    ExecutionFailure execFailure(BuildResult buildResult) {
        OutputScrapingExecutionFailure.from(buildResult.output, buildResult.output)
    }

    private static final String LOWEST_MAJOR_GRADLE_VERSION
    static {

import org.gradle.tooling.UnsupportedVersionException;
import org.gradle.tooling.internal.adapter.ProtocolToModelAdapter;
import org.gradle.tooling.internal.protocol.BuildParameters;
import org.gradle.tooling.internal.protocol.BuildResult;
import org.gradle.tooling.internal.protocol.ConfigurableConnection;
import org.gradle.tooling.internal.protocol.ConnectionMetaDataVersion1;
import org.gradle.tooling.internal.protocol.ConnectionParameters;

import org.gradle.tooling.internal.consumer.versioning.VersionDetails;
import org.gradle.tooling.internal.protocol.BuildParameters;
import org.gradle.tooling.internal.protocol.BuildResult;
import org.gradle.tooling.internal.protocol.InternalBuildActionFailureException;
import org.gradle.tooling.internal.protocol.InternalCancellableConnection;
import org.gradle.tooling.internal.protocol.InternalCancellationToken;