fun <T> serialize(action: TestableIsolatedAction<T>) =
        IsolatedActionSerializer(ownerGradle(), DefaultBeanStateWriterLookup(), isolatedActionCodecsFactory())
            .serialize(action)

    private
    fun <T> deserialize(serialized: SerializedIsolatedActionGraph<TestableIsolatedAction<T>>) =
        IsolatedActionDeserializer(ownerGradle(), beanStateReaderLookupForTesting(), isolatedActionCodecsFactory())

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

    override fun clear() {
        beforeProject.clear()
        afterProject.clear()

inline fun <T : MutableIsolateContext, R> T.withGradleIsolate(
    gradle: Gradle,
    codec: Codec<Any?>,
    block: T.() -> R
): R =
    withIsolate(IsolateOwners.OwnerGradle(gradle), codec) {
        block()

        var allowTaskReferences: Boolean = false
    ) : IsolateOwners() {
        override fun <T> service(type: Class<T>): T = (delegate.project as ProjectInternal).services.get(type)
    }

    class OwnerGradle(override val delegate: Gradle) : IsolateOwners() {
        override fun <T> service(type: Class<T>): T = (delegate as GradleInternal).services.get(type)
    }

                }
            }
        }

    private
    inline fun <R> MutableIsolateContext.withIsolateMock(codec: Codec<Any?>, block: () -> R): R =
        withIsolate(IsolateOwners.OwnerGradle(mock()), codec) {
            block()
        }

    private
    fun writeContextFor(encoder: FlushableEncoder, codec: Codec<Any?>, problemHandler: ProblemsListener) =
        DefaultWriteContext(