func (c *B) Errorf(format string, args ...any)

	// Fail marks the function as having failed but continues ...
	func (c *B) Fail()

	// FailNow marks the function as having failed and stops its ...
	func (c *B) FailNow()

	// Failed reports whether the function has failed. 
	func (c *B) Failed() bool

	// Fatal is equivalent to Log() followed by FailNow(). 
	func (c *B) Fatal(args ...any)

        given:
        configureGarbageCollectionHeapEventsFor(256, 512, 35, garbageCollector.monitoringStrategy.gcRateThreshold + 0.2)

        when:
        run "injectEvents"

        then:
        daemons.daemon.stops()

        and:
        daemons.daemon.log.contains(DAEMON_WILL_STOP_MESSAGE)
        output.contains("""The Daemon will expire after the build after running out of JVM heap space.

public interface TestExecuter<T extends TestExecutionSpec> {

    @UsedByScanPlugin("test-distribution")
    void execute(T testExecutionSpec, TestResultProcessor testResultProcessor);

    /**
     * Stops any {@link TestClassProcessor} utilized by this {@code TestExecuter}.
     */
    @UsedByScanPlugin("test-distribution")
    void stopNow();

     * not use the result processor provided to {@link #startProcessing(TestResultProcessor)} after this method has
     * returned.
     */
    @Override
    void stop();

    /**
     * Stops any pending or asynchronous processing immediately
     *
     * Any test class assigned to this processor, but not yet run will not have results in the output.  The processor should

 */

package org.gradle.workers.internal;

public enum KeepAliveMode {
    /**
     * Keep alive until the end of the build session
     */
    SESSION,
    /**
     * Keep alive until the daemon stops
     */
    DAEMON

     * It should, however, stop accepting new work.</p>
     *
     * <p>
     * Requesting stopping does not guarantee the stoppable actually stops.
     * Requesting stopping means preparing for stopping; stopping accepting new work.
     * You have to call stop at some point anyway if your intention is to completely stop the stoppable.
     */
    void requestStop();

    <T> void run(ConsumerAction<? extends T> action, ResultHandlerVersion1<? super T> handler);

    /**
     * Stops this connection, blocking until all operations on the connection have completed.
     */
    void stop();

    String getDisplayName();

    /**
     * Requests cancellation on the current operation and send a 'stop when idle' message to the daemon.
     */
    void disconnect();

	LoopbackClientConfig *restclient.Config
	// StopCh is the channel that will be closed when the server stops.
	//
	// Deprecated: use the PostStartHookContext itself instead, it contains a context that
	// gets cancelled when the server stops. StopCh keeps getting provided for existing code.
	StopCh <-chan struct{}
	// Context gets cancelled when the server stops.
	context.Context
}

     * The returned {@link Timeout} object must be used to stop the timeout once the thread has completed
     * the work that this timeout was supposed to limit, otherwise it may be interrupted doing
     * some other work later.
     */
    Timeout start(Thread taskExecutionThread, Duration timeoutInMillis, Describable workUnitDescription, @Nullable BuildOperationRef buildOperationRef);

    /**
     * Stops all {@link Timeout}s created from this handler.

    def setup() {
        waitFor = new PollingConditions(timeout: 60, initialDelay: 0, factor: 1.25)
        toolingApi.requireIsolatedDaemons()
    }

    @TargetGradleVersion(">=6.5")
    def "disconnect during build stops daemon"() {
        setup:
        buildFile.text = """
            task hang {
                doLast {
                    ${server.callFromBuild("waiting")}
                }
            }