.solution("Please use 'warningTask2' instead of this task")
        }
    }
}

tasks.register('failingTask') {
    doLast {
        problems.forNamespace('buildscript').throwing {
            it.id('broken-task', 'Task should not be called')
                .contextualLabel("Task 'failingTask' should not be called")
                .severity(Severity.ERROR)

            }
        }
    }

    val failingTask by registering {
        doLast {
            problems.forNamespace("buildscript").throwing {
                id("broken-task", "Task should not be called")
                    .contextualLabel("Task 'failingTask' should not be called")
                    .severity(Severity.ERROR)

        then:
        def e = thrown(BuildActionFailureException)
        e.cause instanceof RuntimeException
        TextUtil.normaliseLineSeparators(e.cause.message) == """Multiple build operations failed.
    broken: one
    broken: two"""
    }

    def setupBuildWithDependencyResolution() {
        server.start()

        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'

     * then the file type of the file metadata is of type
     * {@link org.gradle.internal.file.FileType#Missing}.
     * <p>
     * Such cases include:
     * <ul>
     *     <li>actual missing files</li>
     *     <li>broken symlinks</li>
     *     <li>circular symlinks</li>
     *     <li>named pipes</li>
     * </ul>
     */
    FileMetadata stat(File f);

    }

    def "visitor visits causes of multi-cause exception"() {
        def childCause1 = new RuntimeException()
        def childCause2 = new RuntimeException()
        def cause = new DefaultMultiCauseException("broken", childCause1, childCause2)
        def e = new ContextAwareException(cause)

        when:
        e.accept(visitor)

        then:
        1 * visitor.visitCause(cause)
        1 * visitor.endVisiting()

    String name
    // Url written in the Gradle Module Metadata
    String url
    // Url where this file will be published.
    // Normally publishUrl is the same as url, but it can be set differently for testing some broken behavior.
    String publishUrl
    String ext = 'jar'

    FileSpec(String name) {
        this(name, name, name)
    }

    FileSpec(String name, String url) {
        this(name, url, url)
    }

     * The [KtModule] is being removed. Because this event is published before the removal, the [KtModule] can still be accessed to clear
     * caches. It should be removed from any caches managed by the subscriber to avoid stale or broken keys/values.
     */
    REMOVAL,

            Stub(Path),
            Stub(Path),
            'test project'
        )
        def mid = DefaultModuleVersionIdentifier.newId("foo", "bar", "1.0")
        org.gradle.internal.Factory<String> broken = { "too bad" }
        def dep = new DefaultUnresolvedDependencyResult(
            Stub(ComponentSelector), false,
            Stub(ComponentSelectionReason),

        replaceBody(new SendFixedContent(404, "not found"), null);
        return this;
    }

    @Override
    public BuildableExpectedRequest broken() {
        replaceBody(new SendFixedContent(500, "broken"), null);
        return this;
    }

    @Override
    public BuildableExpectedRequest send(String content) {
        replaceBody(new SendFixedContent(200, content), null);

    }

    def "serializes Throwable"() {
        def failure = new GradleException("broken", new RuntimeException("cause"))

        when:
        def result = serialize(failure, Throwable)

        then:
        result.class == GradleException
        result.message == "broken"
        result.cause.class == RuntimeException
        result.cause.message == "cause"
    }