"unknown"            | "Task 'unknown' not found in root project 'broken' and its subprojects."
        "unknown:help"       | "Cannot locate tasks that match 'unknown:help' as project 'unknown' not found in root project 'broken'."
        ":unknown:help"      | "Cannot locate tasks that match ':unknown:help' as project 'unknown' not found in root project 'broken'."

	})
	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")
            }
        })
    }

        def unused = file("app/src/main/headers/ignore1.h") << "broken!"
        def unusedPrivate = file("app/src/main/cpp/ignore2.h") << "broken!"

        run installApp
        libObjects.snapshot()
        appObjects.snapshot()

        when:
        unused << "even more broken"
        unusedPrivate << "even more broken"
        file("src/main/headers/ignored3.h") << "broken"
        file("src/main/headers/some-dir").mkdirs()

            class MyTask extends DefaultTask {
                @TaskAction void execute() {}
            }

            tasks.create('broken', MyTask)
        """

        expect:
        fails('broken')
        failure.assertHasDescription("A problem was found with the configuration of task ':broken' (type 'MyTask').")
        failure.assertThatDescription(containsString(invalidUseOfCacheableAnnotation {

        buildFile << """
repositories {
    ivy {
        url "${ivyHttpRepo.uri}"
    }
}
configurations { broken }
dependencies {
    broken 'group:projectA:1.3'
}
task showBroken { doLast { println configurations.broken.files } }
"""

        when:
        module.ivy.expectGetBroken()
        fails("showBroken")

        then:
        failure

        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: