* 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)

                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.
     */

     */
    @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();

	b21 := g2.Batch(trace.ThreadID(1), 3)
	b21.Event("ProcStatus", trace.ProcID(1), go122.ProcRunning)
	b21.Event("GoStart", trace.GoID(1), testgen.Seq(2))

	// The goroutine starts running, then stops, then starts again.
	b20 := g2.Batch(trace.ThreadID(0), 5)
	b20.Event("ProcStatus", trace.ProcID(0), go122.ProcRunning)
	b20.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunnable)

// the named files. The returned template's name will have the base name and
// parsed contents of the first file. There must be at least one file.
// If an error occurs, parsing stops and the returned *Template is nil.
//
// When parsing multiple files with the same name in different directories,
// the last one mentioned will be the one that results.

        when: processor.completed("2", complete)

        then:
        1 * redirector.setOutputOwner("1")
        1 * target.completed("2", complete)
        0 * _
    }

    def "stops redirecting when suite is completed"() {
        def test = new DefaultTestDescriptor("2", "Bar", "Baz")
        def testEvent = new TestStartEvent(2, null)
        def complete = new TestCompleteEvent(1)