System.err.is(errInstance)
        System.in.is(inInstance)
    }

    def "tooling api does not replace standard streams while build is running in daemon"() {
        given:
        toolingApi.requireDaemons()
        def outInstance = System.out
        def errInstance = System.err
        def inInstance = System.in
        def handle = sync.expectAndBlock("waiting")

        buildFile << """

    @Timeout(60)
    def "promptly discovers rubbish jvm arguments"() {
        //jvm arguments cannot be set for an existing process
        //so we must not run in embedded mode
        toolingApi.requireDaemons()

        when:
        withConnection {
            it.newBuild()
                    .setJvmArguments("-Xasdf")
                    .run()
        }

        then:

    private String buildOutput

    def setup() {
        // TODO(mlopatkin) Figure a way to have agent-based instrumentation in the embedded TAPI mode.
        toolingApi.requireDaemons()
    }

    def "agent is enabled in TAPI by default"() {
        withDumpAgentStatusTask()

        when:
        runDumpTaskWithTapi()

        then:
        agentWasApplied()
    }

        model.java.javaHome
        !model.java.jvmArguments.empty
    }

    def "informs about java args as in the build script"() {
        given:
        toolingApi.requireDaemons() //cannot be run in embedded mode

        file('build.gradle') <<
            "project.description = java.lang.management.ManagementFactory.runtimeMXBean.inputArguments.join('##')"

        when:

    def setup() {
        if (!dist.toolingApiStdinInEmbeddedModeSupported) {
            // Did not work in embedded mode in older versions
            toolingApi.requireDaemons()
        }
    }

    @Timeout(90)
    def "consumes input when building model"() {
        given:
        file('build.gradle')  << """
description = System.in.text
"""
        when:

    @TargetGradleVersion(">=3.0 <6.3")
    def "invalid Gradle distribution does not kill the TAPI client with older Gradle versions"() {
        given:
        toolingApi.requireDaemons()
        toolingApi.requireIsolatedUserHome()
        withConnection { connection ->
            connection.newBuild().forTasks("wrapper").run()
        }

    def setup() {
        if (!dist.toolingApiStdinInEmbeddedModeSupported) {
            // Did not work in embedded mode in older versions
            toolingApi.requireDaemons()
        }

        file('buildSrc/src/main/java/BuildScanPlugin.java') << buildScanPlugin()
        file('build.gradle') << buildScanPluginApplication()
    }

class JavaConfigurabilityCrossVersionSpec extends ToolingApiSpecification {

    def setup() {
        //this test does not make any sense in embedded mode
        //as we don't own the process
        toolingApi.requireDaemons()
    }

    def "configures the java settings"() {
        when:
        BuildEnvironment env = withConnection {
            def model = it.model(BuildEnvironment.class)
            model

class GradlePropertiesToolingApiCrossVersionSpec extends ToolingApiSpecification {

    def setup() {
        //this test does not make any sense in embedded mode
        //as we don't own the process
        toolingApi.requireDaemons()
    }

    def "tooling api honours jvm args specified in gradle.properties"() {
        file('build.gradle') << """
assert java.lang.management.ManagementFactory.runtimeMXBean.inputArguments.contains('-Xmx62m')

class M9JavaConfigurabilityCrossVersionSpec extends ToolingApiSpecification {

    def setup() {
        //this test does not make any sense in embedded mode
        //as we don't own the process
        toolingApi.requireDaemons()
    }

    def "uses defaults when a variant of empty jvm args requested"() {
        when:
        def env = withConnection {
            it.model(BuildEnvironment.class).setJvmArguments(new String[0]).get()