final connection = new DaemonClientConnection(delegate, daemon, staleAddressDetector)

    def "stops"() {
        when:
        connection.stop()

        then:
        1 * delegate.stop()
        0 * staleAddressDetector._
    }

    def "dispatches messages"() {
        def message = Stub(Message)

        when:

                    }
                }
            """)
        }
    }

    def cleanup() {
        testKitDaemons().visible.each { it.stops() }
    }

        daemons.daemon.assertBusy()
        executer.withArguments("--stop").run()
        def failure = build.waitForFailure()

        then:
        stopsSingleDaemon()
        failure.assertHasDescription(DaemonStoppedException.MESSAGE)

        build.waitForFailure()
    }

    def "can handle multiple concurrent stop requests"() {
        buildFile << """
task block {
    doLast {

/**
 * A {@link org.gradle.internal.concurrent.Stoppable} that stops a collection of things. If an element implements
 * {@link java.io.Closeable} or {@link org.gradle.internal.concurrent.Stoppable} then the appropriate close/stop
 * method is called on that object, otherwise the element is ignored. Elements may be {@code null}, in which case they
 * are ignored.
 *
 * <p>Attempts to stop as many elements as possible in the presence of failures.</p>
 */

// license that can be found in the LICENSE file.

package pe

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"internal/saferio"
	"io"
)

// cstring converts ASCII byte sequence b to string.
// It stops once it finds 0 or reaches end of b.
func cstring(b []byte) string {
	i := bytes.IndexByte(b, 0)
	if i == -1 {
		i = len(b)
	}
	return string(b[:i])
}

// StringTable is a COFF string table.

# This environment variable is an internal implementation detail between the
# Go build system (x/build) and cmd/dist for the purpose of longtest builders,
# and will be removed if it stops being needed. See go.dev/issue/12508.
#
# GO_TEST_TIMEOUT_SCALE: a non-negative integer factor to scale test timeout by.
# Defaults to 1.

set -e

if [ ! -f ../bin/go ]; then

     * All executors immediately stops accepting new jobs. The method blocks until already submitted jobs complete.
     *
     * @throws RuntimeException any exception or error thrown by a job is rethrown from this method, potentially wrapped as a RuntimeException
     */
    public void stop() {
        if (executorService.isShutdown()) {
            return;
        }
        executorService.stop();
    }

        when:
        registry.stop()
        then:
        3 * testHandle.stop()
    }

    def "cannot get a handle once the registry is stopped" () {
        objectFactory.newInstance(TestDeploymentHandle) >> new TestDeploymentHandle()
        given:
        registry.start("id", DeploymentRegistry.ChangeBehavior.NONE, TestDeploymentHandle)
        registry.stop()

        when:

     * @return The proxy.
     */
    <T> T getProxy(Class<T> type);

    /**
     * Stops accepting new method calls, and blocks until all method calls have been executed by the target object.
     *
     * @throws DispatchException When there were any failures dispatching method calls to the target object.
     */
    @Override
    void stop() throws DispatchException;

    long getLogLineCount() {
        return daemonLog.lines().withCloseable { lines -> lines.count() }
    }

    DaemonFixture becomesIdle() {
        waitForState(Idle)
        this
    }

    DaemonFixture stops() {
        waitForState(Stopped)
        this
    }

    @Override
    void assertIdle() {
        assertHasState(Idle)
    }

    @Override
    void assertBusy() {
        assertHasState(Busy)