1 * javaUtilLoggingSystem.restore(javaUtilSnapshot)
        0 * loggingRouter._
        0 * slf4jLoggingSystem._
        0 * javaUtilLoggingSystem._
    }

    public void "can change capture level while started"() {
        final LoggingSystem.Snapshot stdOutSnapshot = Mock(LoggingSystem.Snapshot.class)
        final LoggingSystem.Snapshot stdErrSnapshot = Mock(LoggingSystem.Snapshot.class)

func TestSinglePodOneImageDownloadRecorded(t *testing.T) {

	t.Run("single pod; started in 3s, image pulling 100ms", func(t *testing.T) {

		wants := `
# HELP kubelet_pod_start_sli_duration_seconds [ALPHA] Duration in seconds to start a pod, excluding time to pull images and run init containers, measured from pod creation timestamp to when all its containers are reported as started and observed via watch
# TYPE kubelet_pod_start_sli_duration_seconds histogram

        this.buildCancellationToken = buildCancellationToken;
    }

    public void start() {
        if (started.compareAndSet(false, true)) {
            buildCancellationToken.addCallback(cancellationCallback);
        }
    }

    @Override
    public void stop() {
        if (started.compareAndSet(true, false)) {
            buildCancellationToken.removeCallback(cancellationCallback);
        }
    }

        then:
        noExceptionThrown()

        where:
        notificationMethod | testedIf       | notificationEvent
        'started'          | SimpleDetails  | startedNotification(SimpleDetails)
        'started'          | EmptyDetails   | startedNotification(EmptyDetails)
        'progress'         | SimpleProgress | progressNotification(SimpleProgress)

            this
        }

        ProgressLogger start(String description, String status) {
            setDescription(description)
            started()
            this
        }

        void started() {}

        void started(String status) {
            messages.add(status)
        }

        void progress(String status) {
            messages.add(status)
        }

    /**
     * Creates a new long-running operation which has not been started.
     *
     * @param loggerCategory The logger category.
     * @return The progress logger for the operation.
     */
    ProgressLogger newOperation(String loggerCategory);

    /**
     * Creates a new long-running operation which has not been started.
     *
     * @param loggerCategory The logger category.

    def 'fires start and end events around detector execution'() {
        when:
        action.run()

        then:
        1 * timeProvider.getCurrentTime() >> 100L
        1 * resultProcessor.started({ it.id == 'rootTestSuiteId456' }, { it.startTime == 100L })
        then:
        1 * processor.startProcessing(!null)
        then:
        1* detector.run()
        then:

    }

    def "tooling API client reuses existing daemon started by TAPI"() {
        runBuildViaTAPI()
        def original = getDaemonUID()
        when:
        runBuildViaTAPI()
        then:
        assertSameDaemon(original)
    }

    def "tooling API client reuses existing daemon started by CLI"() {
        runBuildViaCLI()
        def original = getDaemonUID()
        when:

            testsStarted = false;
            currentTests.clear();
            currentTestClass = null;
        }
    }

    @Override
    public void started(TestDescriptorInternal test, TestStartEvent event) {
        resultProcessor.started(test, event);
        testsStarted = true;
        currentTests.add(test.getId());
    }

    @Override
    public void completed(Object testId, TestCompleteEvent event) {

            if (file.endsWith(".gradle.kts")) {
                withProblem("Settings file '${relativePath(file)}': external process started")
            } else {
                withProblem("Settings file '${relativePath(file)}': line 5: external process started")
            }
        }

        where:
        snippetsFactory             | file
        exec().groovy               | "included/settings.gradle"