RenderableOutputEvent event = Mock()
        def failure = new RuntimeException('broken')

        when:
        renderer.onOutput(event)

        then:
        1 * event.render(!null) >> { args -> args[0].exception(failure) }
        output.value == 'java.lang.RuntimeException: broken\n{stacktrace}\n'
    }

    def rendersOutputEventWhenInDebugMode() {

}

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

        given:
        def sourceRetentionAnnotation = annotation("Broken", RetentionPolicy.SOURCE)

        when:
        processor.process([sourceRetentionAnnotation] as Set, roundEnvironment)

        then:
        result.fullRebuildCause.contains("'@Broken' has source retention.")
    }

    }

    AnnotationProcessorDetector detector = new AnnotationProcessorDetector(new TestFileContentCacheFactory(), logger, true)

    def "detects no processors in broken jars"() {
        given:
        def jar = tmpDir.file("classes.jar")
        jar << "broken"
        def cp = files(jar)

        when:
        def processors = detector.detectProcessors(cp)

        then:
        processors == [:]

  }
  return -1;
}"""),
            ]
            List<SourceFile> headerFiles = [
            ]
        }
    }

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

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

                .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)

# Broken config in a yaml config file
#
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: httpbin-gateway
spec:
  selector:
    istio: ingressgateway
---
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: crossnamespace-gw
  namespace: another
spec:
  selector:
    istio: ingressgateway
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:

        expect:
        stream.forCurrentCaller().stack.empty

        def failure1 = new Exception("broken")
        def diagnostics1 = stream.forCurrentCaller(failure1)
        diagnostics1.exception == failure1
        !diagnostics1.stack.empty

        def failure2 = new Exception("broken")
        def diagnostics2 = factory.forException(failure2)
        diagnostics2.exception == failure2

        given:
        buildFile << """
model {
    components {
        main(NativeExecutableSpec)
    }
}
         """

        and:
        file("src/main/rc/broken.rc") << """
        #include <stdio.h>

        NOT A VALID RESOURCE
"""

        expect:
        fails "mainExecutable"

and deploy TensorFlow. This folder is typically used by continuous integration
(CI) tools to build and test TensorFlow whenever there is a change to the
code. This folder is broken into subfolders that represent the level of support