/**
     * Disconnects from the process without waiting for further work.
     */
    void disconnect();

    /**
     * Stops doing work with the process's streams. Should block until no further asynchronous work is happening on the streams.
     */
    @Override
    void stop();

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * A handler that stops all worker daemons when the build is cancelled.
 */
@ServiceScope(Scope.BuildSession.class)
@NonNullApi
public class WorkerDaemonClientCancellationHandler implements Stoppable {

     */
    Address start(IncomingConnectionHandler handler, Runnable connectionErrorHandler);

    /**
     * Stops accepting new connections, and blocks until all active connections close.
     */
    @Override
    public void stop();

            true
        }

        when:
        controller.load(key, cacheableEntity)

        then:
        0 * local.storeLocally(key, _)
    }

    def "stops calling through after read error"() {
        local = null

        when:
        def controller = getController()
        controller.load(key, cacheableEntity)
        controller.load(key, cacheableEntity)

    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