*/
    void requireIsolatedDaemons() {
        if (useSeparateDaemonBaseDir) {
            daemonBaseDir = testWorkDirProvider.testDirectory.file("daemons")
        } else {
            gradleUserHomeDir = testWorkDirProvider.testDirectory.file("user-home-dir")
        }
        requireIsolatedDaemons = true
        requiresDaemon = true
    }

    /**

    }

    def "cleans up resources and files that were not recently used from caches"() {
        given:
        buildscriptWithDependency(snapshotModule)

        when:
        executer.requireIsolatedDaemons() // needs to stop daemon
        succeeds 'resolve'

        then:
        def resource = findFile(cacheDir, 'resources-*/**/maven-metadata.xml')
        def files = findFiles(cacheDir, "files-*/**/*")

                    URLConnection urlConnection = url.openConnection()
                    assert urlConnection.defaultUseCaches
                }
            }
        """
        executer.requireDaemon().requireIsolatedDaemons()

        expect:
        succeeds("checkUrlConnectionCaching")
    }

    def "jars with resources on buildscript classpath can change"() {
        given:
        buildFile << '''

        }
    }
}
        """

                GradleExecuter executer = distribution.executer(workspace, IntegrationTestBuildContext.INSTANCE).
                        requireDaemon().requireIsolatedDaemons().
                        withGradleUserHomeDir(workspace.file("user-home"))
                8.times {
                    executer.inDirectory(buildDir).withArgument("--refresh-dependencies").withTasks('check').run()

        def lastCleanupCheck = initializeHome()

        expect:
        run()
        assertCacheWasNotCleanedUpSince(lastCleanupCheck)
    }

    private long initializeHome() {
        executer.requireIsolatedDaemons() // needs to stop daemon
        requireOwnGradleUserHomeDir() // needs its own journal
        run() // Make sure cache directory is initialized

    }

    def "always cleans up unused version-specific cache directories and corresponding #type distributions when configured"() {
        given:
        executer.requireIsolatedDaemons() // because we want to reuse Gradle user home services
        executer.beforeExecute {
            if (!GradleContextualExecuter.embedded) {
                executer.withArgument("-D$REUSE_USER_HOME_SERVICES=true")

        }

        when:
        executer.withGradleUserHomeDir(homeDirectory)
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
        run 'help'

        then:
        getCompileBuildFileOperationsCount() == 4 // classpath + body for settings and for the 2 identical scripts

        when:
        def before = scriptDetails()

        usesKotlin(file(otherDir))
        // This is because the Kotlin compiler is run in-process (to avoid issues with the Kotlin compiler daemon) and also keeps jars open
        executer.requireDaemon().requireIsolatedDaemons()
        otherDir.file("build.gradle.kts") << """
            dependencies {
                implementation(project(":plugin"))
            }
        """

    }

    def "daemon with different native services flag is not reused"() {
        given:
        executer.requireDaemon()
        executer.requireIsolatedDaemons()

        when:
        executer.withArguments("-D$NATIVE_SERVICES_OPTION=$firstRunNativeServicesOption")
        succeeds()

        then:
        daemons.daemon.becomesIdle()

        when:

class ToolingApiShutdownCrossVersionSpec extends CancellationSpec {

    def waitFor

    def setup() {
        waitFor = new PollingConditions(timeout: 60, initialDelay: 0, factor: 1.25)
        toolingApi.requireIsolatedDaemons()
    }

    @TargetGradleVersion(">=6.5")
    def "disconnect during build stops daemon"() {
        setup:
        buildFile.text = """
            task hang {
                doLast {