* sending incoming messages.
     */
    @Override
    void requestStop();

    /**
     * Performs a graceful stop of this connection. Stops accepting outgoing messages. Blocks until all incoming messages
     * have been handled, and all outgoing messages have been forwarded to the peer.
     */
    @Override
    void stop();

    /**

	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)

	_ "unsafe"
)

//go:linkname heapObjectsCanMove runtime.heapObjectsCanMove
func heapObjectsCanMove() bool

func TestHeapObjectsCanMove(t *testing.T) {
	if heapObjectsCanMove() {
		// If this happens (or this test stops building),
		// it will break go4.org/unsafe/assume-no-moving-gc.
		t.Fatalf("heap objects can move!")
	}

        }
        toolingApi.daemons.daemon.assertIdle()

        when:
        toolingApi.close()

        then:
        toolingApi.daemons.daemon.stops()
    }

    def "cleans up busy daemons once they become idle when tooling API session is shutdown"() {
        given:
        server.start()
        buildFile << """

    boolean isRunning();

    /**
     * Starts the given deployment.
     * @param deployment the deployment to be started
     */
    void start(Deployment deployment);

    /**
     * Stops the deployment.
     */
    void stop();

 */

package org.gradle.internal.execution.timeout;

/**
 * Represents a timeout for some piece of work.
 */
public interface Timeout {
    /**
     * Stops the timeout and returns whether the work did time out.
     */
    boolean stop();

        1 * connection.receive() >> new Success(null)
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()
        1 * connection2.dispatch({it instanceof Stop})
        1 * connection2.receive() >> new Success(null)
        1 * connection2.dispatch({it instanceof Finished})
        1 * connection2.stop()
        0 * _
    }

    def "stops each connection at most once"() {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package iotest

import "io"

// TruncateWriter returns a Writer that writes to w
// but stops silently after n bytes.
func TruncateWriter(w io.Writer, n int64) io.Writer {
	return &truncateWriter{w, n}
}

type truncateWriter struct {
	w io.Writer
	n int64
}

     */
    DaemonFixture becomesIdle();

    /**
     * Asserts that this daemon stops and is no longer visible to any clients within a short timeout. Blocks until this has happened.
     */
    DaemonFixture stops();

    /**
     * Asserts that this daemon is currently idle.
     */
    void assertIdle();

    /**

// CatchSIGIO starts catching SIGIO signals.
//
//export CatchSIGIO
func CatchSIGIO() {
	sigioChan = make(chan os.Signal, 1)
	signal.Notify(sigioChan, syscall.SIGIO)
}

// ResetSIGIO stops catching SIGIO signals.
//
//export ResetSIGIO
func ResetSIGIO() {
	signal.Reset(syscall.SIGIO)
}

// AwaitSIGIO blocks indefinitely until a SIGIO is reported.
//
//export AwaitSIGIO
func AwaitSIGIO() {