println "configurationCache.active=" + buildFeatures.configurationCache.active.get()
                    println "isolatedProjects.requested=" + buildFeatures.isolatedProjects.requested.getOrNull()
                    println "isolatedProjects.active=" + buildFeatures.isolatedProjects.active.get()
                }
            }
        """

        when:
        run "something"
        then:

        return executer == Executer.configCache || executer == Executer.isolatedProjects;
    }

    public static boolean isNotIsolatedProjects() {
        return !isIsolatedProjects();
    }

    public static boolean isIsolatedProjects() {
        return getSystemPropertyExecuter() == Executer.isolatedProjects;
    }

    private GradleExecuter gradleExecuter;

    private final Lazy<BuildFeature> isolatedProjects;

    @Inject
    public DefaultBuildFeatures(StartParameterInternal startParameter, BuildModelParameters buildModelParameters) {
        this.configurationCache = Lazy.atomic().of(() -> createConfigurationCache(startParameter, buildModelParameters));
        this.isolatedProjects = Lazy.atomic().of(() -> createIsolatedProjects(startParameter, buildModelParameters));

    ) {
        this.parallelProjectExecution = parallelProjectExecution;
        this.configureOnDemand = configureOnDemand;
        this.configurationCache = configurationCache;
        this.isolatedProjects = isolatedProjects;
        this.requiresBuildModel = requiresBuildModel;
        this.intermediateModelCache = intermediateModelCache;
        this.parallelToolingApiActions = parallelToolingApiActions;

                    boolean isolatedProjects = buildModelParameters.isIsolatedProjects();
                    GradleProjectBuilderInternal gradleProjectBuilder = createGradleProjectBuilder(isolatedProjects);
                    IdeaModelBuilderInternal ideaModelBuilder = createIdeaModelBuilder(isolatedProjects, gradleProjectBuilder);

            cacheKeyStringFromStartParameter {
                isolatedProjects = Option.Value.value(true)
            },
            equalTo(cacheKeyStringFromStartParameter {
                isolatedProjects = Option.Value.value(true)
            })
        )
        assertThat(
            cacheKeyStringFromStartParameter {
                isolatedProjects = Option.Value.value(true)
            },

        val isolatedProjects = startParameter.isolatedProjects.get()
        val parallelProjectExecution = isolatedProjects || requirements.startParameter.isParallelProjectExecutionEnabled
        val parallelToolingActions = parallelProjectExecution && options.getOption(parallelBuilding).get()
        val invalidateCoupledProjects = isolatedProjects && options.getOption(invalidateCoupledProjects).get()

        builders.register(KotlinBuildScriptTemplateModelBuilder)
        builders.register(IsolatedScriptsModelBuilder)

        if (project.parent == null) {
            val isolatedProjects = project.serviceOf<BuildModelParameters>().isIsolatedProjects
            if (isolatedProjects) {
                builders.register(IsolatedProjectsSafeKotlinDslScriptsModelBuilder(intermediateModelProvider))
            } else {

        def isolatedProjects = new IsolatedProjectsFixture(this)

        when:
        configurationCacheRun "help"
        then:
        configurationCache.assertStateStored()

        when:
        configurationCacheRun "help", "-Dorg.gradle.unsafe.isolated-projects=true"
        then:
        configurationCache.assertStateStored()
        isolatedProjects.assertStateStored {

        return isolatedProjects;
    }

    @SuppressWarnings("deprecation")
    @Override
    public boolean isConfigurationCacheRequested() {
        return configurationCache.get();
    }

    public void setIsolatedProjects(Option.Value<Boolean> isolatedProjects) {
        this.isolatedProjects = isolatedProjects;
    }