when:
        BuildEnvironment env
        GradleProject project
        withConnection {
            env = it.model(BuildEnvironment.class).setJvmArguments('-Xmx200m', '-Xms100m').get()
            project = it.model(GradleProject.class).setJvmArguments('-Xmx200m', '-Xms100m').get()
        }

        then:
        def inputArgsInBuild = project.description.split('##') as List

        then:
        thrown(IllegalStateException)
    }

    def "cleans up idle daemons when tooling API session is shutdown"() {
        withConnection { connection ->
            connection.model(GradleBuild).setJvmArguments(buildJvmArguments).get()
        }
        toolingApi.daemons.daemon.assertIdle()

        when:
        toolingApi.close()

        then:
        toolingApi.daemons.daemon.stops()
    }

    public T setJavaHome(File javaHome) {
        operationParamsBuilder.setJavaHome(javaHome);
        return getThis();
    }

    @Override
    public T setJvmArguments(String... jvmArguments) {
        operationParamsBuilder.setJvmArguments(rationalizeInput(jvmArguments));
        return getThis();
    }

    @Override
    public T addJvmArguments(String... jvmArguments) {

        if (lenient) {
            modelBuilder.setJvmArguments([KotlinDslModelsParameters.CLASSPATH_MODE_SYSTEM_PROPERTY_DECLARATION])
        } else {
            modelBuilder.setJvmArguments([KotlinDslModelsParameters.STRICT_CLASSPATH_MODE_SYSTEM_PROPERTY_DECLARATION])
        }

        if (explicitlyRequestPreparationTasks) {

    }

    @TargetGradleVersion(">=6.6")
    def "can specify options using system properties defined in JVM arguments"() {
        when:
        def result = withBuild { BuildLauncher launcher ->
            launcher.setJvmArguments("-Dorg.gradle.workers.max=12")
        }

        then:
        result.standardOutput.contains("max workers: 12")
    }

    def "command-line arguments take precedence over system properties"() {

        when:
        def env = withConnection {
            it.model(BuildEnvironment.class).setJvmArguments(new String[0]).get()
        }

        def env2 = withConnection {
            it.model(BuildEnvironment.class).setJvmArguments(null).get()
        }

        def env3 = withConnection {
            it.model(BuildEnvironment.class).get()
        }

        then:

        when:
        op.setJvmArguments()

        then:
        op.consumerOperationParameters.jvmArguments == null

        when:
        op.jvmArguments = ['-Xmx']

        then:
        op.consumerOperationParameters.jvmArguments == ['-Xmx']

        when:
        op.setJvmArguments('-Xmx')

        then:

    T setJavaHome(File javaHome);

    /**
     * {@inheritDoc}
     * @since 1.0-milestone-9
     */
    @Override
    T setJvmArguments(String... jvmArguments);

    /**
     * {@inheritDoc}
     * @since 2.6
     */
    @Override
    T setJvmArguments(Iterable<String> jvmArguments);

    /**
     * {@inheritDoc}
     * @since 5.0
     */
    @Override

        //so we must not run in embedded mode
        toolingApi.requireDaemons()

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

        then:
        GradleConnectionException ex = thrown()
        ex.cause.message.contains "-Xasdf"

        when:
        BuildEnvironment env1 = loadBuildEnvironment { builder -> builder.setJvmArguments(JVM_ARG_1).addJvmArguments(JVM_ARG_2) }

        then:
        env1.java.jvmArguments.contains(JVM_ARG_1)
        env1.java.jvmArguments.contains(JVM_ARG_2)

        when:
        BuildEnvironment env2 = loadBuildEnvironment { builder -> builder.setJvmArguments(JVM_ARG_1).addJvmArguments([JVM_ARG_2]) }

        then: