if p == 0 { // starts with incomplete rune
			return -1
		}
		i = p
		info, p = lastRuneStart(fd, b[:i])
		if p == -1 { // incomplete UTF-8 encoding or non-starter bytes without a starter
			return i
		}
	}
	if p+int(info.size) != i { // trailing non-starter bytes: illegal UTF-8
		return i
	}
	if info.BoundaryAfter() {
		return i
	}
	ss := streamSafe(0)
	v := ss.backwards(info)

            this
        }

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

        void started() {}
        void started(String status) {}
        void progress(String status) {}
        void progress(String status, boolean failing) {}
        void completed() {}

    /**
     * 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.

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

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

        then:
        noExceptionThrown()

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

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

    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:

            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"

	// Setup probe "workers" and cached results.
	m.workers = map[probeKey]*worker{
		{testPodUID, notStarted.Name, startup}: {},
		{testPodUID, started.Name, startup}:    {},
	}
	m.startupManager.Set(kubecontainer.ParseContainerID(started.ContainerID), results.Success, &v1.Pod{})

	testCases := []struct {
		desc                    string
		expectedStartup         map[probeKey]bool