return this;
    }

    @Override
    public ExecutionFailure assertThatDescription(Matcher<? super String> matcher) {
        delegate.assertThatDescription(matcher);
        return this;
    }

    @Override
    public ExecutionFailure assertThatAllDescriptions(Matcher<? super String> matcher) {
        delegate.assertThatDescription(matcher);
        return this;
    }

    @Override

        pluginBuilder.publishAs(GROUP, ARTIFACT, VERSION, pluginRepo, executer).allowAll()

        buildScript applyPlugin()

        expect:
        fails("verify")
        failure.assertThatDescription(startsWith("An exception occurred applying plugin request [id: 'org.my.myplugin', version: '1.0']"))
        failure.assertHasLineNumber(3)
        failure.assertHasCause("Could not create plugin of type 'TestPlugin'.")
    }

            plugins {
                id "java"
                id "java"
            }
        """

        when:
        fails "help"

        then:
        failure.assertThatDescription(startsWith("Plugin with id 'java' was already requested at line 3"))
        failure.assertHasFileName("Build file '$buildFile.absolutePath'")
        failure.assertHasLineNumber(4)
    }

        buildScript """
            $USE
        """

        then:
        fails "tasks"

        and:
        failure.assertThatDescription(startsWith("Plugin [id: 'org.myplugin', version: '1.0'] was not found in any of the following sources"))
        failure.assertThatDescription(containsString("""
            - Plugin Repositories (could not resolve plugin artifact 'org.myplugin:org.myplugin.gradle.plugin:1.0')

            }
'''

        then:
        fails "build"

        and:
        failure.assertHasFileName("Build file '${other}'")
        failure.assertHasLineNumber(2)
        failure.assertThatDescription(CoreMatchers.startsWith("A problem occurred evaluating project ':other'"))
        failure.assertHasCause('broken')
    }

    def reportsBuildSrcFailure() {
        when:

        given:
        prepareWrapper()

        when:
        def failure = wrapperExecuter.withTasks('unknown').runWithFailure()

        then:
        failure.assertThatDescription(CoreMatchers.startsWith("Task 'unknown' not found in root project"))
    }

    @Issue("https://github.com/gradle/gradle/issues/16055")
    def "can run in project with a \$ in the path"() {
        given:

        }
        return this;
    }

    @Override
    public ExecutionFailure assertHasDescription(String context) {
        assertThatDescription(startsWith(context));
        return this;
    }

    @Override
    public ExecutionFailure assertThatDescription(Matcher<? super String> matcher) {
        assertHasFailure(matcher, f -> {
        });
        return this;
    }

    @Override

        ExecutionFailure result = inTestDirectory().withTasks("test").runWithFailure();
        result.assertThatDescription(startsWith("Multiple projects in this build have project directory"));

        result = usingProjectDir(getTestDirectory()).withTasks("test").runWithFailure();
        result.assertThatDescription(startsWith("Multiple projects in this build have project directory"));

        executer.expectDeprecationWarnings(1);

        fails("broken")

        and:
        // Ensure the failure is a location that the fixtures can see
        if (level == LogLevel.DEBUG) {
            failure.assertThatDescription(containsString("Execution failed for task ':broken'"))
        } else {
            failure.assertHasDescription("Execution failed for task ':broken'")
        }
        failure.assertHasCause("broken")

     *
     * <p>Error messages are normalized to use new-line char as line separator.
     */
    ExecutionFailure assertThatDescription(Matcher<? super String> matcher);

    /**
     * Asserts that there all failures match the given description (ie the bit after '* What went wrong').
     *