def requested = newSelector(group, module, version)
        org.gradle.internal.Factory<String> broken = { "broken" }
        new DefaultUnresolvedDependencyResult(requested, false, ComponentSelectionReasons.requested(), newModule(group, module, selectedVersion), new ModuleVersionResolveException(newSelector(DefaultModuleIdentifier.newId(group, module), version), broken))
    }

        !lines.contains('lifecycle')
        !lines.contains('warn')
    }

    def "broken listener fails build but does not kill logging output"() {
        buildFile << """
            class BrokenListener implements StandardOutputListener {
                void onOutput(CharSequence output) {
                    throw new RuntimeException("broken")
                }
            }
            def output = new BrokenListener()

            task broken
        """

        when:
        executer.expectDocumentedDeprecationWarning("Listener registration using Gradle.addListener() has been deprecated. This will fail with an error in Gradle 9.0. Consult the upgrading guide for further information: https://docs.gradle.org/current/userguide/upgrading_version_7.html#task_execution_events")
        run("broken")

        then:
        noExceptionThrown()

                @Override String obtain() {
                    if (Boolean.getBoolean("should.fail")) {
                        throw new RuntimeException("Broken!")
                    }
                    return "not broken"
                }
            }

            providers.of(SometimesBrokenValueSource) {}.get()
        """)

        when:
        configurationCacheRun()

            context.visitPropertyProblem {
                it
                    .forProperty(metadata.propertyName)
                    .id("test-problem", "is broken", GradleCoreProblemGroup.validation())
                    .documentedAt(userManual("id", "section"))
                    .severity(Severity.WARNING)
                    .details("Test")
            }
        }

dependencies {
    compile files { throw new RuntimeException('broken') }
    compile files('lib.jar')
}

${showFailuresTask(expression)}
"""
        when:
        fails 'show'

        then:
        failure.assertHasCause("Could not resolve all artifacts for configuration ':compile'.")
        failure.assertHasCause("broken")

        where:

        settingsFile << """
            rootProject.name = 'test'
            sourceControl {
                vcsMappings {
                    withModule("broken") {
                        from(GitVersionControlSpec) {
                        }
                    }
                }
            }
        """

        expect:
        fails('assemble')

        descriptor.versions == ['1.2', '1.3'] as Set
    }

    def "can mark as failed"() {
        org.gradle.internal.Factory<String> broken = { "too bad" }
        def failure = new ModuleVersionResolveException(newSelector(DefaultModuleIdentifier.newId("a", "b"), "c"), broken)

        when:
        descriptor.failed(failure)

        then:
        descriptor.state == Failed
        descriptor.failure == failure

    @org.testng.annotations.Test
    public void passingTest() {
    }

    @org.testng.annotations.Test(expectedExceptions = RuntimeException.class)
    public void expectedFailTest() {
        throw new RuntimeException("broken");
    }

        // maybe killed here
        if (parameters.broken.get()) {
            Runtime.runtime.halt(1)
        }
        def two = outputs.file("two")
        two.text = "two"
    }
}

dependencies {
    registerTransform(ToColor) {
        from.attribute(type, "jar")
        to.attribute(type, "red")
        parameters {
            color = Color.Red