setup:
        def opts = createOpts()

        when:
        opts.debug = true
        opts.debugOptions.port.set(port)
        opts.debugOptions.server.set(server)
        opts.debugOptions.suspend.set(suspend)

        then:
        opts.allJvmArgs.findAll { it.contains 'jdwp' } == [expected]

        where:
        port | server | suspend | expected

object BeanCodec : Codec<Any> {

    override suspend fun WriteContext.encode(value: Any) {
        encodePreservingIdentityOf(value) {
            val beanType = GeneratedSubclasses.unpackType(value)
            withBeanTrace(beanType) {
                writeBeanOf(beanType, value)
            }
        }
    }

    override suspend fun ReadContext.decode(): Any =
        decodePreservingIdentity { id ->

import org.gradle.internal.serialize.graph.ReadContext
import org.gradle.internal.serialize.graph.WriteContext


object UnitCodec : Codec<Unit> {

    override suspend fun WriteContext.encode(value: Unit) {
        // noop
    }

    override suspend fun ReadContext.decode() {
        // returns Unit instance under the hood
    }

 */
object HashSetCodec : Codec<HashSet<Any?>> {

    override suspend fun WriteContext.encode(value: HashSet<Any?>) {
        writeCollectionCheckingForCircularElements(value)
    }

    override suspend fun ReadContext.decode(): HashSet<Any?> =
        readCollectionCheckingForCircularElementsInto(::LinkedHashSet)
}


private
suspend fun WriteContext.writeCollectionCheckingForCircularElements(collection: Collection<Any?>) {

    override suspend fun WriteContext.encode(value: InputStream) {
        if (value !== System.`in`) {
            logUnsupportedBaseType("serialize", InputStream::class, unpackType(value), appendix = supportedStreamsInfo())
            writeEnum(StreamReference.UNSUPPORTED)
            return
        }
        writeEnum(StreamReference.IN)
    }

    override suspend fun ReadContext.decode(): InputStream? {

 */
fun <T : ReadContext, R> T.runReadOperation(readOperation: suspend T.() -> R): R {
    contract {
        callsInPlace(readOperation, InvocationKind.EXACTLY_ONCE)
    }
    return runToCompletion {
        readOperation()
    }
}


/**
 * Runs the given [writeOperation] synchronously.
 */
fun <T : WriteContext, U> T.runWriteOperation(writeOperation: suspend T.() -> U): U =
    runToCompletion {
        writeOperation()

 */
class BeanSpec(val bean: Any)


object BeanSpecCodec : Codec<BeanSpec> {

    override suspend fun WriteContext.encode(value: BeanSpec) =
        encodeBean(value.bean)

    override suspend fun ReadContext.decode(): BeanSpec =
        BeanSpec(decodeBean())

import java.lang.reflect.Method


object MethodCodec : Codec<Method> {

    override suspend fun WriteContext.encode(value: Method) {
        writeClass(value.declaringClass)
        writeString(value.name)
        writeClassArray(value.parameterTypes)
    }

    override suspend fun ReadContext.decode(): Method? {
        val declaringClass = readClass()
        val methodName = readString()

        setup:
        sampleProject """
            debugOptions {
                enabled = true
                server = false
                suspend = false
            }

            jvmArgs "-agentlib:jdwp=transport=dt_socket,server=n,suspend=n,address=$debugClient.port"
        """

        debugClient.listen()

        expect:
        succeeds(taskName)

            ?: EnumSubTypeEncoding.takeIf { type.superclass?.isEnum == true }

    override suspend fun ReadContext.decode(): Any? {
        val enumClass = readClass()
        val enumOrdinal = readSmallInt()
        return enumClass.enumConstants[enumOrdinal]
    }
}


private
object EnumEncoding : Encoding {
    override suspend fun WriteContext.encode(value: Any) {
        writeEnumValueOf(value::class.java, value)
    }
}