&& Objects.equals(host.getOrNull(), that.host.getOrNull())
            && port.get().equals(that.port.get())
            && server.get() == that.server.get()
            && suspend.get() == that.suspend.get();
    }

    @Override
    public Property<Boolean> getEnabled() {
        return enabled;
    }

    @Override
    @Optional
    public Property<String> getHost() {

     * of stored included build directories.
     */
    suspend fun DefaultWriteContext.writeRootBuildState(build: VintageGradleBuild) {
        writeBuildInvocationId()
        writeRootBuild(build).also {
            writeInt(0x1ecac8e)
        }
    }

    suspend fun DefaultReadContext.readRootBuildState(
        graph: BuildTreeWorkGraph,

        5005 || "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005"
        5006 || "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5006"
    }

    def "can configure debug suspend"() {
        given:
        parameters.setDebug(true)

        when:
        parameters.setDebugSuspend(suspend)

        then:
        parameters.effectiveJvmArgs.contains(debugArgument)

        }
    }

    private
    suspend fun WriteContext.writeRequiredServices(task: TaskInternal) {
        writeCollection(task.requiredServices.searchServices())
    }

    private
    suspend fun ReadContext.readRequiredServices(task: TaskInternal) {
        readCollection {
            task.usesService(readNonNull())
        }
    }

    private

    override suspend fun WriteContext.encode(value: PatternSet) {
        writePatternSet(value)
    }

    override suspend fun ReadContext.decode() =
        patternSetFactory.create()!!.apply {
            readPatternSet(this)
        }
}


object IntersectionPatternSetCodec : Codec<IntersectionPatternSet> {

    override suspend fun WriteContext.encode(value: IntersectionPatternSet) {

suspend fun test() {
    <expr>call(1, "foo")</expr>
}

	// Serialize thread suspension. SuspendThread is asynchronous,
	// so it's otherwise possible for two threads to suspend each
	// other and deadlock. We must hold this lock until after
	// GetThreadContext, since that blocks until the thread is
	// actually suspended.
	lock(&suspendLock)

	// Suspend the thread.
	if int32(stdcall1(_SuspendThread, thread)) == -1 {
		unlock(&suspendLock)

    override suspend fun WriteContext.encode(value: T) {
        encodePreservingSharedIdentityOf(value) { doEncode(value) }
    }

    override suspend fun ReadContext.decode(): T =
        decodePreservingSharedIdentity { doDecode() }

    protected
    abstract suspend fun WriteContext.doEncode(value: T)

    protected
    abstract suspend fun ReadContext.doDecode(): T

        }
    }

    private
    suspend fun WriteContext.writeConfigurations(candidates: LocalComponentGraphResolveState.LocalComponentGraphSelectionCandidates) {
        writeCollection(candidates.allSelectableVariants) {
            writeConfiguration(it)
        }
    }

    private
    suspend fun WriteContext.writeConfiguration(configuration: VariantGraphResolveState) {

/**
 * Binary encoding for type [T].
 */
interface Codec<T> : EncodingProvider<T>, DecodingProvider<T>


interface EncodingProvider<T> {
    suspend fun WriteContext.encode(value: T)
}


interface DecodingProvider<T> {
    suspend fun ReadContext.decode(): T?
}


interface WriteContext : IsolateContext, MutableIsolateContext, Encoder {

    val tracer: Tracer?