boolean modelAsProjectDependency,
        LogLevel configurationCacheLogLevel
    ) {
        this.parallelProjectExecution = parallelProjectExecution;
        this.configureOnDemand = configureOnDemand;
        this.configurationCache = configurationCache;
        this.isolatedProjects = isolatedProjects;
        this.requiresBuildModel = requiresBuildModel;
        this.intermediateModelCache = intermediateModelCache;

        file("gradle.properties") << "org.gradle.configureondemand=true"
        buildFile << "assert gradle.startParameter.configureOnDemand"
        expect:
        run()
    }

    def "can be enabled from command line and start parameter informs about it, too"() {
        file("gradle.properties") << "org.gradle.configureondemand=false"

        createDirs("api", "impl")

        when:
        file('gradle.properties') << """
org.gradle.configureondemand=true
"""
        buildFile << """
task assertCodEnabled {
    doLast {
        assert gradle.startParameter.configureOnDemand
    }
}

task assertCodDisabled {
    doLast {
        assert !gradle.startParameter.configureOnDemand
    }
}
"""

        then:
        succeeds ':assertCodEnabled'

        }

        then:
        buildWasCancelled(resultHandler)

        where:
        configureOnDemand << [true, false]
    }

    def "can cancel model creation during configuration phase"() {
        file("gradle.properties") << "org.gradle.configureondemand=${configureOnDemand}"
        setupCancelInConfigurationBuild()

        def cancel = GradleConnector.newCancellationTokenSource()

        then:
        gradle.rootBuild >> true
        modelParameters.configureOnDemand >> true
    }

    def "configures non-root build for on demand mode"() {
        when:
        configurer.prepareProjects(gradle)

        then:
        gradle.rootBuild >> false
        modelParameters.configureOnDemand >> true
        1 * projectConfigurer.configureHierarchy(rootProject)
    }

     */
    void setGradleHomeDir(File gradleHomeDir) {
        this.gradleHomeDir = gradleHomeDir;
    }

    @Incubating
    public void setConfigureOnDemand(boolean configureOnDemand) {
        this.configureOnDemand = configureOnDemand;
    }

    public boolean isContinuous() {
        return continuous;
    }

    public void setContinuous(boolean enabled) {
        this.continuous = enabled;

                configurationCacheLogLevel
            )
        } else {
            val configurationCache = isolatedProjects || startParameter.configurationCache.get()
            val configureOnDemand = isolatedProjects || startParameter.isConfigureOnDemand

            fun disabledConfigurationCacheBuildModelParameters(buildOptionReason: String): BuildModelParameters {

        when:
        StartParameter newParameter = parameter.newBuild()

        then:
        newParameter != parameter

        newParameter.configureOnDemand == parameter.configureOnDemand
        newParameter.gradleUserHomeDir == parameter.gradleUserHomeDir
        newParameter.logLevel == parameter.logLevel
        newParameter.consoleOutput == parameter.consoleOutput

import org.gradle.tooling.model.GradleProject

class ToolingApiConfigurationOnDemandCrossVersionSpec extends ToolingApiSpecification {

    def setup() {
        file("gradle.properties") << "org.gradle.configureondemand=true"
    }

    def "building model evaluates all projects regardless of configuration on demand mode"() {
        given:
        file("settings.gradle") << "include 'api', 'impl', 'other'"

    def setup() {
        file("gradle.properties") << "org.gradle.configureondemand=true"
    }

    @Requires(
        value = [IntegTestPreconditions.NotParallelExecutor, IntegTestPreconditions.NotIsolatedProjects],
        reason = "these features hide incubating message"
    )
    def "presents incubating message"() {
        file("gradle.properties") << "org.gradle.configureondemand=false"
        buildFile << "task foo"

        when: