HashCode getSecondaryInputHash();

    void isolateParametersIfNotAlready();

    FileNormalizer getInputArtifactNormalizer();

    FileNormalizer getInputArtifactDependenciesNormalizer();

    boolean isIsolated();

    DirectorySensitivity getInputArtifactDirectorySensitivity();

    DirectorySensitivity getInputArtifactDependenciesDirectorySensitivity();

    LineEndingSensitivity getInputArtifactLineEndingNormalization();

        return fileNormalizer;
    }

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

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

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

    @Override

        expect:
        def original = 123
        def isolated = isolatableFactory.isolate(original)
        isolated.coerce(Integer).is(original)
        isolated.coerce(Number).is(original)
        isolated.coerce(Long) == null
        isolated.coerce(Short) == null
        isolated.coerce(Byte) == null
        isolated.coerce(String) == null
    }

    def "creates isolated long"() {
        expect:
        def original = 123L

				if isIsolate {
					validIsolateCount++
				}
				// Push new embedding level, override status, and isolated
				// status.
				// No check for valid stack counter, since the level check
				// suffices.
				switch t {
				case LRO:
					stack.push(newLevel, L, isIsolate)
				case RLO:
					stack.push(newLevel, R, isIsolate)
				default:

        snapshot != snapshotter.snapshot("other")
    }

    def "creates snapshot for isolated string"() {
        expect:
        def isolated = isolatableFactory.isolate("abc")
        snapshotter.snapshot("abc") == snapshotter.snapshot(isolated)
        snapshotter.snapshot("other") != snapshotter.snapshot(isolated)
    }

    def "creates snapshot for integer"() {
        expect:

        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.

    configurations.ok.attributes.attribute(attr, value)

    value[0].name = 'other'
    value.add(new Thing(name: 'c'))

    def isolated = configurations.ok.attributes.getAttribute(attr)
    assert isolated.size() == 2
    assert isolated[0].name == 'a'
    assert isolated[1].name == 'b'
"""

        expect:
        succeeds()
    }

        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
     */