* limitations under the License.
 */

package org.gradle.operations.configuration;

/**
 * Signals whether Isolated Projects has been enabled in the build.
 *
 * @since 8.3
 */
public interface IsolatedProjectsSettingsFinalizedProgressDetails {

    /**
     * Whether Isolated Projects is enabled for the build.
     */
    boolean isEnabled();

    /**
     * Indicates that this task is isolated and so does not require the project lock in order to execute.
     */
    public void isolated() {
        isolated = true;
    }

    public WorkValidationContext getValidationContext() {
        return validationContext;
    }

    @Nullable
    @Override
    public ResourceLock getProjectToLock() {
        if (isolated) {
            return null;
        } else {

                parameter = "42"
            }
        '''
    }

    def configuredTaskRunsCorrectly() {
        run 'test'
        outputContains 'The parameter is `42`'
        true
    }

    def 'isolated beforeProject action given as Kotlin lambda can capture managed value'() {
        given:
        withSettingsPluginInBuildLogic()

        createDir('build-logic') {
            file('settings.gradle.kts') << ''

     * the convention computation that is not compatible with Isolated Projects.
     */
    public @Nullable IdeaLanguageLevel getRawLanguageLevel() {
        return languageLevel;
    }

    /**
     * Returns the user-defined value for the {@link #getTargetBytecodeVersion()} without triggering
     * the convention computation that is not compatible with Isolated Projects.
     */

     * the convention computation that is not compatible with Isolated Projects.
     */
    @Nullable
    public IdeaLanguageLevel getRawLanguageLevel() {
        return languageLevel;
    }

    /**
     * Returns the user-defined value for the {@link #getTargetBytecodeVersion()} without triggering
     * the convention computation that is not compatible with Isolated Projects.
     */
    @Nullable

    /**
     * @see org.gradle.api.invocation.GradleLifecycle#afterProject(IsolatedAction)
     */
    void afterProject(IsolatedAction<? super Project> action);

    /**
     * Returns an isolated listener for the registered actions, if any. The listener makes it impossible for
     * the actions to carry any shared mutable state across projects and can be safely executed in parallel.
     */
    @Nullable

        minimumPluginVersionForConfigurationCaching | true
    }

    @Requires(value = IntegTestPreconditions.NotConfigCached, reason = "Isolated projects implies config cache")
    def "shows warning message when Develocity plugin version is used with isolated projects enabled"() {
        given:
        plugin.runtimeVersion = pluginVersion
        plugin.artifactVersion = pluginVersion
        applyPlugin()

While containers provide isolated application execution environment, orchestration platforms allow seamless scaling by helping replicate and manage containers. MinIO extends this by adding isolated storage environment for each tenant.

        original = Thread.currentThread().contextClassLoader
    }

    def cleanup() {
        Thread.currentThread().contextClassLoader = original
    }

    def "classes from specified URLs are visible in isolated ClassLoader"() {
        when:
        def cl = factory.createIsolatedClassLoader("test", classpath)
        def c = cl.loadClass(DefaultClassLoaderFactoryTestHelper.name)

        then:

     * Note that the state may not be immutable, so should be made isolated to reuse in another context. The state can also be fingerprinted to generate a fingerprint of this object.
     *