when:
        run "th"

        then:
        result.assertTasksExecuted(":a:thing", ":b:thing", ":a:a:thing", ":b:b:thing")
    }

    @ToBeFixedForIsolatedProjects(because = "subprojects")
    def "stops traversing sub-projects when task implies sub-projects"() {
        createDirs("a", "b", "a/a", "b/b")
        settingsFile << "include 'a', 'b', 'a:a', 'b:b'"

        buildFile << """
            subprojects {

    /**
     * <p>Requests that the daemon stop, but wait until the daemon is idle. The stop will happen asynchronously, and this method does not block.
     *
     * <p>The daemon will stop accepting new work, so that subsequent calls to {@link #runCommand} will fail with {@link DaemonUnavailableException}.
     */
    void requestStop(String reason);

    /**

//
// Transitions to and from states that are Executing are special in that
// they change the future execution context. In other words, future events
// on the same thread will feature the same goroutine until it stops running.
//
// Panics if d.Resource.Kind is not ResourceGoroutine.
func (d StateTransition) Goroutine() (from, to GoState) {
	if d.Resource.Kind != ResourceGoroutine {

// immediately deferred t.Stop after calling NewTicker, to make
// the ticker recoverable when it was no longer needed.
// As of Go 1.23, the garbage collector can recover unreferenced
// tickers, even if they haven't been stopped.
// The Stop method is no longer necessary to help the garbage collector.
// (Code may of course still want to call Stop to stop the ticker for other reasons.)
func NewTicker(d Duration) *Ticker {

        this.executorFactory = executorFactory;
    }

    /**
     * Stops all actors.
     */
    @Override
    public void stop() {
        synchronized (lock) {
            try {
                CompositeStoppable.stoppable(nonBlockingActors.values()).add(blockingActors.values()).stop();
            } finally {
                nonBlockingActors.clear();
            }
        }
    }

)

// Type of service signals currently supported.
type serviceSignal int

const (
	serviceRestart       serviceSignal = iota // Restarts the server.
	serviceStop                               // Stops the server.
	serviceReloadDynamic                      // Reload dynamic config values.
	serviceFreeze                             // Freeze all S3 API calls.

        when:
        handler.reservePort()
        handler.start(10, {})
        handler.stop()

        then:
        1 * factory.create(_ as String) >> lockRequestListener
        1 * factory.create(_ as String) >> releaseLockActionExecutor
        1 * lockRequestListener.stop()
        1 * releaseLockActionExecutor.stop()
    }

    def "stopping is safe even if the handler was not initialized"() {
        when:

            // See: https://android.googlesource.com/platform/tools/base/+/studio-master-dev/build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ShaderCompile.java#120
            // TODO: remove this once AGP stops checking for the existence of these directories at configuration time
            workingDir.listFiles().findAll { it.isDirectory() && new File(it, "build.gradle").exists() }.each {

env GO111MODULE=on
env proxy=$GOPROXY
env GOPROXY=direct

# GOVCS stops go get
env GOVCS='*:none'
! go get github.com/google/go-cmp
stderr '^go: GOVCS disallows using git for public github.com/google/go-cmp; see ''go help vcs''$'
env GOPRIVATE='github.com/google'
! go get github.com/google/go-cmp
stderr '^go: GOVCS disallows using git for private github.com/google/go-cmp; see ''go help vcs''$'

# public pattern works

    private
    val loaders = mutableMapOf<ClassLoader, Pair<ClassLoaderScopeSpec, ClassLoaderRole>>()

    override fun afterStart() {
        listenerManager.add(this)
    }

    /**
     * Stops recording [ClassLoaderScopeSpec]s and releases any recorded state.
     */
    fun dispose() {
        synchronized(lock) {
            // TODO:configuration-cache find a way to make `dispose` unnecessary;