return fileNormalizer;
    }

    @Override
    public FileNormalizer getInputArtifactDependenciesNormalizer() {
        return dependenciesNormalizer;
    }

    @Override
    public boolean isIsolated() {
        return isolatedParameters.isFinalized();
    }

    @Override
    public boolean requiresDependencies() {
        return requiresDependencies;
    }

    @Override

        List<String> list = ["foo", "bar"]

        when:
        serialize(isolatableFactory.isolate(list))

        and:
        Isolatable<?>[] newIsolatables = deserialize()

        then:
        newIsolatables[0].isolate() == list
    }

    def "can serialize/deserialize isolated Set"() {
        Set<String> list = ["foo", "bar"]

        when:

:gradle-issues: https://github.com/gradle/gradle/issues/

= Isolated Projects

Isolated Projects is a pre-alpha Gradle feature that extends the configuration cache to further improve performance, in particular the performance of Android Studio and IDEA sync.

When isolated projects is enabled, the configuration model of Gradle projects are "isolated" from each other.

        then: "fetching with Isolated Projects"
        fixture.assertStateStored {
            modelsCreated(":", GradleProject, IsolatedGradleProjectInternal)
            modelsCreated(":lib1", IsolatedGradleProjectInternal)
        }

        checkGradleProject(projectModel, expectedProjectModel)

        when: "fetching again with Isolated Projects"

     * @see IsolatedAction for the requirements to isolated actions
     * @since 8.8
     */
    @Incubating
    void beforeProject(IsolatedAction<? super Project> action);

    /**
     * Adds an {@link IsolatedAction isolated action} to be called immediately after a project is evaluated.
     *
     * @param action The action to execute.
     * @see IsolatedAction for the requirements to isolated actions
     * @since 8.8
     */

        reply.class == payloadClass
    }

    def "handles nested objects which are not visible from root object ClassLoader"() {
        def parent = isolated(WrapperPayload, PayloadInterface)
        def wrapperClass = parent.loadClass(WrapperPayload.name)
        def payloadClass = isolated(parent, CustomPayload).loadClass(CustomPayload.name)
        assertNotVisible(wrapperClass, payloadClass)

    @Requires(value = IntegTestPreconditions.NotConfigCached, reason = "Isolated projects implies config cache")
    def "can use plugin #version with isolated projects"() {
        given:
        def versionNumber = VersionNumber.parse(version)

        when:
        usePluginVersion version

        then:
        scanRunner("-Dorg.gradle.unsafe.isolated-projects=true")

        then:
        configurationCache.assertStateLoaded()
    }

    @Issue("https://github.com/gradle/gradle/issues/26049")
    // Isolated Projects option is explicitly controlled by the test
    @Requires(IntegTestPreconditions.NotIsolatedProjects)
    def "isolated projects flag is part of the cache key"() {
        def isolatedProjects = new IsolatedProjectsFixture(this)

        when:
        configurationCacheRun "help"

        expect:
        rootProject.isolated.path == ":"
        rootProject.isolated.buildTreePath == ':'

        child1.isolated.path == ":child1"
        child1.isolated.buildTreePath == ":child1"

        child2.isolated.path == ":child1:child2"
        child2.isolated.buildTreePath == ":child1:child2"

        nestedRootProject.isolated.path == ":"

        """

        when: "fetching without Isolated Projects"
        def originalIdeaModel = fetchModel(IdeaProject)

        then:
        fixture.assertNoConfigurationCache()
        originalIdeaModel.modules.size() == 3
        originalIdeaModel.modules.every { it.children.isEmpty() } // IdeaModules are always flattened

        when: "fetching with Isolated Projects"
        executer.withArguments(ENABLE_CLI)