}

    @Requires(UnitTestPreconditions.SmartTerminalAvailable)
    def "returns metadata when only stdout is attached to console"() {
        given:
        terminals.isTerminal(Terminals.Output.Stdout) >> true
        terminals.isTerminal(Terminals.Output.Stderr) >> false

        expect:
        detector.console != null
        detector.console.stdOut
        !detector.console.stdErr
    }

  name: system:node-problem-detector
subjects:
- kind: ServiceAccount
  name: node-problem-detector
  namespace: kube-system
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: node-problem-detector
  namespace: kube-system
  labels:
    app.kubernetes.io/name: node-problem-detector
    app.kubernetes.io/version: v0.8.19
    addonmanager.kubernetes.io/mode: Reconcile
spec:
  selector:
    matchLabels:

    def delegate = Mock(CompareStrategy.ChangeDetector)
    def detector = new TrivialChangeDetector(itemComparator, changeFactory, delegate)

    def change = Mock(Change)
    def visitor = Mock(ChangeVisitor)

    def "detects no change between empty current and previous"() {
        when:
        detector.visitChangesSince([:], [:], "test", visitor)
        then:
        0 * _
    }

    private final Runnable detector;
    private final TestClassProcessor processor;
    private final TestResultProcessor resultProcessor;
    private final WorkerLeaseService workerLeaseService;
    private final Clock clock;
    private final Object rootTestSuiteId;
    private final String displayName;

    public static final String TEST_CONSOLE_PROPERTY = "org.gradle.internal.console.test-console";

    private final ConsoleDetector detector;

    public TestOverrideConsoleDetector(ConsoleDetector detector) {
        this.detector = detector;
    }

    @Nullable
    @Override
    public ConsoleMetaData getConsole() {
        String testConsole = System.getProperty(TEST_CONSOLE_PROPERTY);

    private final TestResultProcessor resultProcessor = Mock()
    private final Runnable detector = Mock()
    private final Clock timeProvider = Mock()
    private final WorkerLeaseRegistry.WorkerLease lease = Mock()
    private final WorkerLeaseService workerLeaseService = Mock()
    private final TestMainAction action = new TestMainAction(detector, processor, resultProcessor, workerLeaseService, timeProvider, "rootTestSuiteId456", "Test Run")

        addClass(cl, impl)

        expect:
        detector.cache.size() == 1

        when:
        cl.clearCache()

        then:
        ConcurrentTestUtil.poll(10) {
            System.gc()
            detector.cache.cleanUp()
            detector.cache.size() == 0
        }

        where:
        impl << [
                "class SomeThing {}",
                "class SomeThing extends ${RuleSource.name} {}",

    DefaultJvmVersionDetector detector = new DefaultJvmVersionDetector(
        new DefaultJvmMetadataDetector(
            TestFiles.execHandleFactory(),
            TestFiles.tmpDirTemporaryFileProvider(tmpDir.testDirectory)
        )
    )

    def "can determine version of current jvm"() {
        expect:
        detector.getJavaVersionMajor(Jvm.current()) == JavaVersion.current().majorVersionNumber

        it
    }
    AnnotationProcessorDetector detector = Stub(AnnotationProcessorDetector)
    Compiler<JavaCompileSpec> delegate = Stub(Compiler)

    AnnotationProcessorDiscoveringCompiler compiler = new AnnotationProcessorDiscoveringCompiler(delegate, detector)

    def "when neither processor path nor processor option are given, no processors are used"() {
        when:

        0 * _
    }

    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 == [:]