Adrian Kuegel <******@****.***> 1648469008 -0700

        def string2 = "bar"
        Isolatable<?>[] isolatables = [isolatableFactory.isolate(string1), isolatableFactory.isolate(string2)]

        when:
        serialize(isolatables)

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

        then:
        newIsolatables[0].isolate() == string1
        newIsolatables[1].isolate() == string2
    }

    def "can serialize/deserialize isolated Boolean values"() {

        expect:
        isolatableFactory.isolate(true).isolate()
        !isolatableFactory.isolate(false).isolate()
    }

    def "can coerce boolean value"() {
        expect:
        isolatableFactory.isolate(true).coerce(Boolean)
        !isolatableFactory.isolate(false).coerce(Boolean)
        isolatableFactory.isolate(false).coerce(String) == null
    }

inline fun <reified T> IsolateOwner.serviceOf() = service(T::class.java)


interface Isolate {

    val owner: IsolateOwner
}


interface WriteIsolate : Isolate {

    /**
     * Identities of objects that are shared within this isolate only.
     */
    val identities: WriteIdentities
}


interface ReadIsolate : Isolate {

    /**

    }

    @Override
    public Object isolate() {
        return factory.fromState(targetType, state.isolate());
    }

    @Nullable
    @Override
    public <S> S coerce(Class<S> type) {
        if (type.isAssignableFrom(targetType)) {
            return type.cast(isolate());
        }
        return type.cast(factory.fromState(type, state.isolate()));
    }

    public int getFactoryId() {

        beforeProject.isEmpty() && afterProject.isEmpty() -> null
        else -> {
            val isolate = isolate(
                IsolatedProjectActions(beforeProject, afterProject),
                IsolateOwners.OwnerGradle(gradle)
            )
            clear()
            IsolatedProjectEvaluationListener(gradle, isolate)
        }
    }

    override fun clear() {
        beforeProject.clear()

    /**
     * Let Gradle decide, this is the default.
     */
    AUTO,
    /**
     * Don't attempt to isolate the work, use in-process workers.
     */
    NONE,
    /**
     * Isolate the work in its own classloader, use in-process workers.
     */
    CLASSLOADER,
    /**
     * Isolate the work in a separate process, use out-of-process workers.
     */
    PROCESS

    protected
    abstract fun newIsolate(owner: IsolateOwner): T

    protected
    fun getIsolate(): T = currentIsolate.let { isolate ->
        require(isolate != null) {
            "`isolate` is only available during Task serialization."
        }
        isolate
    }

    protected
    fun getCodec() = currentCodec

    private
    val contexts = ArrayList<Pair<T?, Codec<Any?>>>()

        snapshotter.snapshot(false).is BooleanValueSnapshot.FALSE
    }

    def "creates snapshot for isolated boolean"() {
        expect:
        def isolated = isolatableFactory.isolate(true).isolate()
        snapshotter.snapshot(true) == snapshotter.snapshot(isolated)
        snapshotter.snapshot(false) != snapshotter.snapshot(isolated)
    }

    def "creates snapshot for null value"() {

    }

    override suspend fun ReadContext.decode(): Task? = when (readEnum<ReferenceType>()) {
        ReferenceType.SELF_REF ->
            isolate.owner.delegate as Task

        ReferenceType.TASK_REF -> {
            val taskName = readString()
            isolate.owner.service(TaskContainerInternal::class.java).resolveTask(taskName)
        }

        ReferenceType.PROHIBITED -> {
            logUnsupported(