then:
        assertSameDaemon(original)
    }

    def "CLI reuses existing daemon started by TAPI"() {
        runBuildViaTAPI()
        def original = getDaemonUID()
        when:
        runBuildViaCLI()
        then:
        assertSameDaemon(original)
    }

    String getDaemonUID() {
        toolingApi.daemons.daemon.context.uid
    }

    void assertSameDaemon(String expectedUID) {

        def daemon2 = Stub(DaemonConnectDetails)

        when:
        client.gracefulStop([daemon1, daemon2])

        then:
        1 * connector.maybeConnect(daemon1) >>> connection
        _ * connection.daemon >> daemon1
        1 * connection.dispatch({it instanceof StopWhenIdle})
        1 * connection.receive() >> new Success(null)
        1 * connection.dispatch({it instanceof Finished})

        String gradleVersion = (output =~ /GRADLE_VERSION: (.*)/)[0][1]
        daemons(gradleVersion).daemons.size() == 1

        where:
        javaToolOptions << ["-Xms513m", "-Xmx255m", "-Xms128m -Xmx256m"]
    }

    @Requires(UnitTestPreconditions.Jdk16OrEarlier) // TraceClassLoading option has been deprecated and is removed in JDK17
    def 'can start the daemon with ClassLoading tracing enabled'() {
        given:

        //
        // We isolate the Gradle daemons so we know the daemons are only used for these particular tests.
        //
        // To workaround a msbuild issue, we require the daemon to be used by the test executor, so the Gradle daemon will be
        // started before msbuild is executed.
        // If msbuild starts the Gradle daemon, it will wait for the Gradle daemon to exit before moving on to the next msbuild task.

            assert !gradle.isRunning()
        }

        and:
        !output.contains(DaemonMessages.CANCELED_BUILD)
        !daemons.daemon.log.contains(DaemonMessages.CANCELED_BUILD)

        cleanup:
        daemons.killAll()
    }

    DaemonsFixture getDaemons() {
        new DaemonLogsAnalyzer(executer.daemonBaseDir)
    }

                    // ignore
                }
                return new DaemonExpirationResult(DaemonExpirationStatus.GRACEFUL_EXPIRE, "expiring daemon with TestExpirationStrategy uuid: \${dc?.getUid()}")
            }
        }

        def daemon =  services.get(Daemon)
        daemon.scheduleExpirationChecks(new AllDaemonExpirationStrategy([new TestExpirationStrategy(project)]), $EXPIRATION_CHECK_FREQUENCY)
        """
    }

        // Expire recently unused Daemons when memory pressure is high
        addLowMemoryDaemonExpirationStrategyWhenSupported(daemon, strategies, listenerManager);

        // Expire when Daemon Registry becomes unreachable for some reason
        strategies.add(new DaemonRegistryUnavailableExpirationStrategy(daemon));

class StdioIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        executer.requireDaemon()
        // This isn't actually required - the test is fine with shared daemons
        // In fact, it would be much better to test this feature using shared daemons
        executer.requireIsolatedDaemons()
    }

    def "task can read stdin when stdin has bounded length"() {
        given:
        buildFile << '''
task echo {

 */
public interface InternalInvalidatableVirtualFileSystemConnection extends InternalProtocolInterface {

    /**
     * Notifies all daemons about file changes made by an external process, like an IDE.
     *
     * <p>The daemons will use this information to update the retained file system state.
     *
     * <p>The paths which are passed in need to be absolute, canonicalized paths.

     * @since 5.6
     */
    WorkQueue classLoaderIsolation();

    /**
     * Creates a {@link WorkQueue} to submit work for asynchronous execution in a daemon process.
     *
     * Work will execute in an idle daemon, if available.  If no idle daemons are available, a new daemon will be started.
     *
     * @since 5.6
     */
    WorkQueue processIsolation();

    /**