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;

	return Option{
		InitialInterval: defaultInitialInterval,
		MaxInterval:     defaultMaxInterval,
	}
}

// NewExponentialBackOff creates an istio wrapped ExponentialBackOff.
// By default, it never stops.
func NewExponentialBackOff(o Option) BackOff {
	b := ExponentialBackOff{}
	b.exponentialBackOff = backoff.NewExponentialBackOff()
	b.exponentialBackOff.InitialInterval = o.InitialInterval

# Test that when the coordinator experiences an I/O error communicating
# with a worker, the coordinator stops the worker and reports the error.
# The coordinator should not record a crasher.
#
# We simulate an I/O error in the test by writing garbage to fuzz_out.
# This is unlikely, but possible. It's difficult to simulate interruptions
# due to ^C and EOF errors which are more common. We don't report those.
[short] skip
[!fuzz] skip
env GOCACHE=$WORK/cache

    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)

}

// ResultChan returns a channel which will receive filtered events.
func (fw *filteredWatch) ResultChan() <-chan Event {
	return fw.result
}

// Stop stops the upstream watch, which will eventually stop this watch.
func (fw *filteredWatch) Stop() {
	fw.incoming.Stop()
}

// loop waits for new values, filters them, and resends them.
func (fw *filteredWatch) loop() {
	defer close(fw.result)

                LOGGER.debug("Requesting daemon {} stop when idle", daemon);
                stopDispatcher.dispatch(connection, new StopWhenIdle(idGenerator.generateId(), connection.getDaemon().getToken()));
                LOGGER.lifecycle("Gradle daemon stopped.");
            } finally {
                connection.stop();
            }
        }
    }

    /**
     * Stops all daemons, blocking until all have completed.
     */

	# At that point, we expect the subprocess to print 'stdin closed'
	# and periodically log to stderr until the WaitDelay expires.
	#
	# Once the WaitDelay expires, the copying goroutine for 'go test' stops and
	# closes the read side of the stderr pipe, and the subprocess will eventually
	# exit due to a failed write to that pipe.

stdout '^--- PASS: TestOrphanCmd .*\nPASS\nstdin closed'

     */
    @Override
    LoggingManagerInternal start();

    /**
     * Stops logging, restoring the log manger that was active when {@link #start()} was called on this manager. Shuts down the logging system when there was no log manager active prior to starting this one.
     */
    @Override
    LoggingManagerInternal stop();

    /**
     * Consumes logging from System.out and System.err and Java util logging.
     */

     */
    void setDebugLoggingEnabled(boolean debugLoggingEnabled);

    /**
     * Close the watcher registry. Stops watching without handling the changes.
     */
    @Override
    void close() throws IOException;

    interface FileWatchingStatistics {
        Optional<Throwable> getErrorWhileReceivingFileChanges();