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:

    @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")

        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)

        val startParameter = requirements.startParameter

        // Isolated projects also implies configuration cache
        if (startParameter.isolatedProjects.get() && !startParameter.configurationCache.get()) {
            if (startParameter.configurationCache.isExplicit) {
                throw GradleException("The configuration cache cannot be disabled when isolated projects is enabled.")
            }
        }

        this.displayName = displayName;
        this.resolver = fileResolver;
        this.dependencyFactory = dependencyFactory;
        this.host = host;
        this.valueState = ValueState.newState(host, ValueCollector::isolated);
        init(EMPTY_COLLECTOR, EMPTY_COLLECTOR);
        filesWrapper = new PathSet();
        buildDependency = dependencyFactory.configurableDependency();
    }

    }

    @Issue("https://github.com/gradle/gradle/issues/10411")
    @Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = "This test requires isolated daemons")
    def "does not leak project state across multiple builds"() {
        fixture.withWorkActionClassInBuildSrc()
        executer.withBuildJvmOpts('-Xms256m', '-Xmx512m').requireIsolatedDaemons().requireDaemon()

    If you want this update with the old behavior use [this interceptor][legacy_interceptor].

 *  Fix: Don't crash decompressing web sockets messages. We had a bug where we assumed deflated
    bytes in would always yield deflated bytes out and this isn't always the case!

 *  Fix: Reliably update and invalidate the disk cache on windows. As originally designed our

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl.isolated

import org.gradle.api.provider.Property
import org.gradle.util.internal.ToBeImplemented
import spock.lang.Issue

class IsolatedProjectsAccessFromGroovyDslIntegrationTest extends AbstractIsolatedProjectsIntegrationTest {

        then:
        cachedClasspath.asFiles == [cachedFile]
        def zip = new ZipTestFixture(cachedFile)
        zip.hasCompression("a.class", ZipEntry.DEFLATED)
        zip.hasCompression("res.txt", ZipEntry.STORED)
    }

    def "uses non-file URL from origin"() {
        given:
        def file = testDir.file("thing.jar")
        jar(file)