})
	if err != nil {
		c.events.Write(pod, corev1.EventTypeWarning, ReasonDeleteBrokenPod, "pod detected as broken, but failed to delete: %v", err)
		m.With(resultLabel.Value(resultFail)).Increment()
		return err
	}
	c.events.Write(pod, corev1.EventTypeWarning, ReasonDeleteBrokenPod, "pod detected as broken, deleted")
	m.With(resultLabel.Value(resultSuccess)).Increment()
	return nil
}

        server.expect("/cache/${key.hashCode}", false, [method], new HttpServer.ActionSupport("return ${httpCode} broken") {
            @Override
            void handle(HttpServletRequest request, HttpServletResponse response) {
                //noinspection GrDeprecatedAPIUsage
                response.setStatus(httpCode, "broken")
            }
        })
    }

        metadata.missing = true
        metadata.status = "broken"

        expect:
        def immutable = metadata.asImmutable()
        immutable.changing
        immutable.missing
        immutable.status == "broken"

        def copy = immutable.asMutable()
        copy.changing
        copy.missing
        copy.status == "broken"

        def immutable2 = copy.asImmutable()

                @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:

import org.gradle.internal.service.ServiceRegistry
import spock.lang.Specification

class RepositoryChainComponentMetaDataResolverTest extends Specification {
    final org.gradle.internal.Factory<String> broken = { "broken" }
    final metaData = metaData("1.2")
    final componentState = Stub(ModuleComponentGraphResolveState) {
        getLegacyMetadata() >> metaData
    }

        settingsFile << "include 'child'"
        def m1 = mavenHttpRepo.module('org.foo', 'hiphop').publish()
        def m2 = mavenHttpRepo.module('org.foo', 'unknown')
        def m3 = mavenHttpRepo.module('org.foo', 'broken')
        def m4 = mavenHttpRepo.module('org.foo', 'rock').dependsOn(m3).publish()

        buildFile << """
            dependencies {
                implementation 'org.foo:hiphop:1.0'

        given:
        buildFile << """
            task broken() {
                doLast {
                    println "Hello"
                }
                timeout = Duration.ofMillis(-1)
            }
            """

        expect:
        2.times {
            fails "broken"
            failure.assertHasDescription("Execution failed for task ':broken'.")

        given:
        app.writeToProject(testDirectory)
        file("src/main/cpp/ignore.swift") << 'broken!'
        file("src/main/cpp/ignore.c") << 'broken!'
        file("src/main/cpp/ignore.m") << 'broken!'
        file("src/main/cpp/ignore.h") << 'broken!'
        file("src/main/cpp/ignore.java") << 'broken!'

        and:
        buildFile << """
            apply plugin: 'cpp-application'
         """