import org.hamcrest.Matcher;

import java.util.function.Consumer;

public interface ExecutionFailure extends ExecutionResult {
    /**
     * {@inheritDoc}
     */
    @Override
    ExecutionFailure getIgnoreBuildSrc();

    ExecutionFailure assertHasLineNumber(int lineNumber);

    ExecutionFailure assertHasFileName(String filename);

    /**
     * Asserts that the given number of failures are present.

public class ErrorsOnStdoutScrapingExecutionFailure extends ErrorsOnStdoutScrapingExecutionResult implements ExecutionFailure {
    private final ExecutionFailure delegate;

    public ErrorsOnStdoutScrapingExecutionFailure(ExecutionFailure delegate) {
        super(delegate);
        this.delegate = delegate;
    }

    @Override
    public ExecutionFailure getIgnoreBuildSrc() {

        }
        return result
    }

    @Override
    protected ExecutionFailure doRunWithFailure() {
        ExecutionResult result = executeInContainer()
        if (!(result instanceof ExecutionFailure)) {
            throw new AssertionError("Expected build to fail but it passed")
        }
        (ExecutionFailure) result
    }

    @Override
    void assertCanExecute() throws AssertionError {

        return "(?m)^" + repeat(" ", prefix);
    }

    @Override
    public ExecutionFailure assertHasLineNumber(int lineNumber) {
        assertThat(this.lineNumbers, hasItem(equalTo(String.valueOf(lineNumber))));
        return this;
    }

    @Override
    public ExecutionFailure assertHasFileName(String filename) {
        assertThat(this.fileNames, hasItem(equalTo(filename)));

            def result = null
            usingToolingConnection(workingDir) {
                result = action(it)
            }
            result
        }
    }

    ExecutionFailure runFailingBuildWithToolingConnection(Function<ProjectConnection, ExecutionFailure> action) {
        // Can just run the action
        return runBuildWithToolingConnection(action)
    }

        }
    }

    private static class InProcessExecutionFailure extends InProcessExecutionResult implements ExecutionFailure {
        private static final Pattern LOCATION_PATTERN = Pattern.compile("(?m)^((\\w+ )+'.+') line: (\\d+)$");
        private final ExecutionFailure outputFailure;
        private final Throwable failure;
        private final List<String> fileNames = new ArrayList<>();

    }

    void assertFailureHasError(
        ExecutionFailure failure,
        String error,
        @DelegatesTo(value = HasConfigurationCacheErrorSpec, strategy = Closure.DELEGATE_FIRST) Closure<?> specClosure
    ) {
        assertFailureHasError(failure, error, ConfigureUtil.configureUsing(specClosure))
    }

    void assertFailureHasError(
        ExecutionFailure failure,
        String error,

        waitForBuild()
        if (result instanceof ExecutionFailure) {
            throw new UnexpectedBuildFailure("build was expected to succeed but failed")
        }
        failure = null
        result
    }

    ExecutionFailure fails() {
        waitForBuild()
        if (!(result instanceof ExecutionFailure)) {

    }

    ExecutionFailure buildTriggeredAndFailed() {
        if (!gradle.isRunning()) {
            throw new UnexpectedBuildFailure("Gradle has exited")
        }
        waitForBuild()
        return extractFailure()
    }

    private ExecutionFailure extractFailure() {
        if (!(result instanceof ExecutionFailure)) {

    private
    fun ExecutionFailure.assertHasWarningLineFor(script: File) =
        assertHasErrorOutput(warningLineFor(script))

    private
    fun warningLineFor(script: File) =
        "w: ${clickableUrlFor(script)}:3:1: 'SomeDeprecatedType' is deprecated. BECAUSE"

    private
    fun ExecutionFailure.assertHasDetailedErrorOutput() =
        assertHasErrorOutput(