then:
        succeeds("test")

        when:
        testSourceFile << " broken "

        then:
        buildTriggeredAndFailed()
        failureDescriptionStartsWith("Execution failed for task ':compileTestJava'.")

        when:
        sourceFile << " broken "

        then:
        buildTriggeredAndFailed()

        ex.evaluationCycle.size() == 2
        // Have to use reference check because owner's equals is broken
        ex.evaluationCycle[0] === owner
        ex.evaluationCycle[1] === owner

        where:
        evaluator << [evaluateInLambda(), evaluateInBlock()]
    }

    def "can handle owner with broken equals in tryEvaluate"() {
        given:
        owner.equals(_) >> { false }

        when:

        when:
        buildScript '''
            class ThrowingRule extends RuleSource {
                @Mutate
                void badRule(Task echo) {
                    throw new RuntimeException("I'm broken")
                }
            }

            class Rules extends RuleSource {
                @Mutate
                void addTasks(ModelMap<Task> tasks) {

        0 * visitor._
    }

    @Requires(UnitTestPreconditions.Jdk11OrLater)
    def "throws FileException on badly formed JAR"() {
        def visitor = Mock(ClasspathEntryVisitor)
        def file = tmpDir.file("broken").createFile()

        when:
        walker.visit(file, visitor)

        then:
        thrown(FileException)

        0 * visitor._
    }

        then:
        output.value == '[message]\n'
    }

    def formatsException() {
        when:
        output.exception(new RuntimeException('broken'))

        then:
        output.value == 'java.lang.RuntimeException: broken\n{stacktrace}\n'
    }

    def canMixInStyleInformation() {
        when:
        output.style(Style.Info).text('info test').style(Style.Normal)

        then:

        1 * details.producerValue >> "value2"
        1 * details.compatible()
    }

    static class BrokenRule implements AttributeCompatibilityRule<String> {
        static failure = new RuntimeException("broken")

        @Override
        void execute(CompatibilityCheckDetails<String> details) {
            throw failure
        }
    }

    def "wraps failure to execute rule"() {

            }
        """
    }

    @Override
    List<String> getPluginList() {
        ['objective-cpp']
    }

    SourceFile getBrokenFile() {
        return sourceFile("objcpp", "broken.mm", """'broken""")
    }

    @Override
    String getSourceSetType() {
        return "ObjectiveCppSourceSet"
    }

        when:
        processor.testClassFinished(null)

        then:
        1 * target.completed(1, {it.endTime == 1300})
        0 * target._
    }

    def "synthesises a broken test when test class fails and no tests have been started"() {
        def failure = TestFailure.fromTestFrameworkFailure(new RuntimeException())

        given:
        idGenerator.generateId() >>> [1, 2]

        and:

        """
        file("inc/settings.gradle") << """
            include 'sub'
        """
        file("inc/sub/build.gradle") << """
            gradle.buildFinished { }
            tasks.register('broken') {
                inputs.property('p', project).optional(true)
                doLast { t -> t.project }
            }
        """

        when:
        configurationCacheFails ":inc:sub:broken"

}

var podResourceDesc = resourceMetricsDescriptors{
	requests: resourceLifecycleDescriptors{
		total: metrics.NewDesc("kube_pod_resource_request",
			"Resources requested by workloads on the cluster, broken down by pod. This shows the resource usage the scheduler and kubelet expect per pod for resources along with the unit for the resource if any.",
			[]string{"namespace", "pod", "node", "scheduler", "priority", "resource", "unit"},