}

    public LogLevel getConfigurationCacheLogLevel() {
        return configurationCacheLogLevel;
    }

    public boolean isIsolatedProjects() {
        return isolatedProjects;
    }

    /**
     * When {@link  #isIsolatedProjects()} is true, should intermediate tooling models be cached?
     * This is currently true when fetching a tooling model, otherwise false.
     */

        //   Isolated Projects.
        if (isIsolatedProjects()) {
            gradle.getLifecycle().beforeProject(action::execute);
        } else {
            gradle.allprojects(action);
        }
    }

    private boolean isIsolatedProjects() {
        return features.getIsolatedProjects().getActive().getOrElse(false);
    }

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

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

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

    private GradleExecuter gradleExecuter;

    }

    def "runs action after running tasks when task execution is requested and isolated projects disabled"() {
        def action = Mock(BuildTreeModelAction)
        buildModelParameters.isIsolatedProjects() >> false
        startParameter.getTaskRequests() >> [new DefaultTaskExecutionRequest(["tasks"])]

        when:
        def result = controller.fromBuildModel(true, action)

        then:

     *
     * Uses a build model parameter rather than a start parameter as the latter is not final and can be affected by other options of the build.
     */
    val isIsolatedProjects: Boolean
        get() = modelParameters.isIsolatedProjects
}


private
fun InternalOptions.getInternalFlag(systemPropertyName: String, defaultValue: Boolean = false): Boolean =

        });

        eventEmitter.emitNowForCurrent(new IsolatedProjectsSettingsFinalizedProgressDetails() {
            @Override
            public boolean isEnabled() {
                return buildModelParameters.isIsolatedProjects();
            }
        });
    }

        builders.register(IsolatedScriptsModelBuilder)

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

            } else {
                registration.addProvider(VintageBuildControllerProvider())
                registration.add(DefaultEnvironment::class.java)
            }
            if (buildModelParameters.isIsolatedProjects) {
                registration.addProvider(ConfigurationCacheIsolatedProjectsProvider())
            } else {
                registration.addProvider(VintageIsolatedProjectsProvider())
            }

                @Override
                public void execute(ToolingModelBuilderRegistry registry) {
                    boolean isolatedProjects = buildModelParameters.isIsolatedProjects();
                    GradleProjectBuilderInternal gradleProjectBuilder = createGradleProjectBuilder(isolatedProjects);

        Provider<Boolean> isRequested = getRequestedProvider(startParameter.getIsolatedProjects());
        Provider<Boolean> isActive = Providers.of(buildModelParameters.isIsolatedProjects());
        return new DefaultBuildFeature(isRequested, isActive);
    }

    private static ProviderInternal<Boolean> getRequestedProvider(Option.Value<Boolean> optionValue) {