@Rule
    BlockingHttpServer server = new BlockingHttpServer()

    VerboseVfsLogAccessor vfsLogs

    def setup() {
        executer.requireDaemon()
        executer.beforeExecute {
            vfsLogs = enableVerboseVfsLogs()
        }
        server.start()
        settingsFile  << """
            import org.gradle.internal.file.FileType

            newContainer()
                .withBuildDir(testBuildDir)
                .withExecuter {
                    if (daemon) {
                        requireDaemon()
                        requireIsolatedDaemons()
                    }
                    it
                }
        }

        synchronizer.expectConcurrent(ids.collect { "build$it".toString() })

    @Requires(UnitTestPreconditions.Symlinks)
    @Issue("https://github.com/gradle/gradle/issues/9202")
    def "source mapping file works with symlinks"() {
        // Daemon cleans up symlinks in VFS
        executer.requireDaemon()
        executer.requireIsolatedDaemons()

        given:
        buildFile << """
            sourceSets {
                main {
                    ${languageName} {

    def "forks build when default client VM memory is used and user didn't specify a different limit"() {
        executer.withCommandLineGradleOpts('-Xmx64m')
        executer.useOnlyRequestedJvmOpts()
        executer.requireDaemon()

        when:
        succeeds()

        then:
        wasForked()

        and:
        daemons.daemon.stops()
    }

    def "stops single use daemon when build fails"() {

        executer.gradleUserHomeDir.file(BuildScopeCacheDir.UNDEFINED_BUILD).assertDoesNotExist()
    }

    def "does not fail when executing #flag in undefined build"() {
        when:
        executer.requireDaemon().requireIsolatedDaemons()
        succeeds(flag)

        then:
        testDirectory.assertIsEmptyDir()

        where:
        flag << ["--version", "--help", "-h", "-?", "--help"]
    }

    def setup() {
        expectReindentedValidationMessage()

        // Must run on isolated daemons so that symlink data can be properly cleaned up between builds
        executer.requireDaemon()
        executer.requireIsolatedDaemons()

        buildFile << """
// This is a workaround to bust the JVM's file canonicalization cache
def f = file("delete-me")
f.createNewFile()

import org.gradle.test.preconditions.IntegTestPreconditions

@LocalOnly
class LoggingFileSystemWatchingIntegrationTest extends AbstractFileSystemWatchingIntegrationTest {

    def setup() {
        executer.requireDaemon()
    }

    def "verbose VFS logging can be enabled"() {
        buildFile << """
            apply plugin: "java"
        """
        when:

        hasSystemProperty('mySystemProperty', 'defined in the client JVM')
    }

    def "Client JVM system properties do not appear in the build if withSystemProperties() is called"() {
        setup:
        toolingApi.requireDaemons() // no separate daemon JVM -> all client JVM system properties are expected to be visible

        when:
        runTask { withSystemProperties('unrelated' : 'value') }

        then:

    @TargetGradleVersion(">=3.5")
    @Requires(UnitTestPreconditions.Jdk8OrEarlier)
    def "old versions can mutate environment on JDK < 9"() {
        given:
        toolingApi.requireDaemons() //cannot be run in embedded mode

        buildFile << """
            task printEnv() {
                doLast {
                    println "<" + System.getenv() + ">"
                }
            }"""

 */
abstract class ToolingApiLoggingSpecification extends ToolingApiSpecification {
    def setup() {
        if (!targetDist.toolingApiLoggingInEmbeddedModeSupported) {
            toolingApi.requireDaemons()
        }
    }