toolchains { // should be toolchain
                }
            }
        """

        expect:
        fails()
        failure.assertThatCause(containsNormalizedString("Could not find method toolchains() for arguments"))
        failure.assertThatCause(containsNormalizedString(" on extension 'java' of type org.gradle.api.plugins.internal.DefaultJavaPluginExtension."))
    }

    public ExecutionFailure assertHasCause(String description) {
        delegate.assertHasCause(description);
        return this;
    }

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

    @Override
    public ExecutionFailure assertHasDescription(String context) {
        delegate.assertHasDescription(context);

        """

        then:
        fails "tasks"
        failure.assertHasLineNumber(15)
        failure.assertThatCause(containsString("Invalid model path given as rule input."))
        failure.assertThatCause(containsString("Model path 'foo. bar' is invalid due to invalid name component."))
        failure.assertThatCause(containsString("Model element name ' bar' has illegal first character ' ' (names must start with an ASCII letter or underscore)."))

            run.args '${veryLongCommandLineArgs.join("','")}'
        """

        when:
        fails taskName

        then:
        failure.assertThatCause(containsText("could not be started because the command line exceed operating system limits."))

        where:
        method                    | taskName
        'JavaExec task'           | 'run'

        then:
        fails 'checkDeps'

        and:
        failedResolve.assertFailurePresent(failure)
        failure
            .assertResolutionFailure(':compile')
            .assertThatCause(CoreMatchers.containsString('Received status code 401 from server: Unauthorized'))

        where:
        authScheme | credsName | creds
        BASIC      | 'missing' | ''
        DIGEST     | 'missing' | ''

            failure.assertThatCause(containsNormalizedString("The only attribute distinguishing these variants is 'org.gradle.usage'. Add this attribute to the consumer's configuration to resolve the ambiguity:"))
            failure.assertThatCause(containsNormalizedString("- Value: 'unknownApiVariant' selects variant: 'api'"))

            someMethod()
        """

        when:
        fails "help"

        then:
        failure.assertHasFileName("Script '${file("script2.gradle").absolutePath}'")
        failure.assertThatCause(containsText("Could not find method someMethod()"))
    }

    def "methods defined in settings script are not inherited by scripts"() {
        given:
        settingsFile << """
            def someMethod() {}

                nonPublic = "foo"
            }
        """
        fails(":printTestSoftwareTypeExtensionImplConfiguration")

        then:
        failure.assertThatCause(Matchers.containsString("Failed to interpret the declarative DSL file"))
        failure.assertThatCause(Matchers.containsString("unresolved reference 'nonPublic'"))
    }

    def 'can declare and configure a custom software type from a parent class'() {
        given:

        failure.assertHasCause("A build operation failed.")
        def exeName = executable("build/binaries/mainExecutable/main").file.name
        failure.assertThatCause(containsText("Linker failed while linking ${exeName}"))
    }

    @ToBeFixedForConfigurationCache
    def "build fails when link library fails"() {
        given:
        buildFile << """

        when:
        fails "clean"

        then:
        failure.assertThatCause(containsString("Unable to delete directory '${file('build')}'"))
        failure.assertThatCause(containsString("Failed to delete some children. This might happen because a process has files open or has its working directory set in the target directory."))
        failure.assertThatCause(containsString(file("build/newFile").absolutePath))

        cleanup: