.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 {

    }

    fun runTask(task: String): BuildResult {
        return GradleRunner.create()
                .withProjectDir(testProjectDir.root)
                .withArguments(task, "--stacktrace")
                .withPluginClasspath()
                .build()
    }

    fun runTaskWithFailure(task: String): BuildResult {
        return GradleRunner.create()

        def model = new Object()
        def modelType = Object
        def buildResult = Stub(BuildResult) {
            getModel() >> model
        }

        when:
        def result = controller.getModel(null, modelType, null, null)

        then:
        1 * delegate.getModel(null, {it.name == Object.name}) >> buildResult
        0 * delegate._

        and:
        result == model
    }

    @Override
    public void buildFinished(BuildResult result) {
        this.action = result.getAction();
    }

    public void logResult(Throwable buildFailure) {
        if (action == null) {
            // This logger has been replaced (for example using `Gradle.useLogger()`), so don't log anything
            return;
        }
        BuildResult buildResult = new BuildResult(action, null, buildFailure);

        withConnection {
            runBuild {
                succeeds()
                cancel()
            }
            assert !buildResult.failure
            runBuild {
                succeeds()
                cancel()
            }
        }

        then:
        !buildResult.failure
    }

    def "can cancel in subsequent wait period"() {
        when:
        runBuild {
            succeeds()

Output:
$t.buildResult.output"""

        def buildOutput = OutputScrapingExecutionResult.from(t.buildResult.output, "")
        buildOutput.assertTasksExecuted(":helloWorld")
        buildOutput.groupedOutput.task(":helloWorld").output == "Hello world!"

        normaliseLineSeparators(t.message).startsWith(normaliseLineSeparators(expectedMessage))
        t.buildResult.taskPaths(SUCCESS) == [':helloWorld']
    }

 *
 * @since 2.6
 * @see GradleRunner#build()
 */
public class UnexpectedBuildFailure extends UnexpectedBuildResultException {
    public UnexpectedBuildFailure(String message, BuildResult buildResult) {
        super(message, buildResult);
    }

 */
public interface GradleEnterprisePluginEndOfBuildListener {

    interface BuildResult {
        @Nullable
        Throwable getFailure();

        Collection<Problem> getProblems();

        Collection<Problem> getProblemsFor(Throwable failure);
    }

    void buildFinished(BuildResult buildResult);

         */
        BuildScanResult execute(BuildResult buildResult);
    }

    void notify(Listener listener);

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