override suspend fun WriteContext.encode(value: Any) {
            encodePreservingIdentityOf(value) {
                val beanType = value.javaClass
                val record = recordWritingOf(beanType, value)
                writeEnum(Format.WriteObject)
                writeClass(beanType)
                record.run { playback() }
            }
        }

                override fun connectionAcquired(
                  call: Call,
                  connection: Connection,
                ) {
                  socketClass = connection.socket().javaClass.name
                }
              },
            ),
          )
          .sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
          .build()

    ): R =
        readerContextFor(inputStream).let { (context, codecs) ->
            context.use {
                context.run {
                    initClassLoader(javaClass.classLoader)
                    runReadOperation {
                        readOperation(codecs)
                    }.also {
                        finish()
                    }
                }

        Platform.resetForTests(platform)
      } else {
        Platform.resetForTests()
      }

      if (requiredPlatformName != null) {
        System.err.println("Running with ${Platform.get().javaClass.simpleName}")
      }
    }

    fun resetPlatform() {
      if (platform != null) {
        Platform.resetForTests()
      }
    }

    fun expectFailureOnConscryptPlatform() {

                    writeCollection(task.outputs.cacheIfSpecs)
                    writeCollection(task.outputs.doNotCacheIfSpecs)
                    writeReasonNotToTrackState(task)
                    beanStateWriterFor(task.javaClass).run {
                        writeStateOf(task)
                        withTaskReferencesAllowed {
                            writeRegisteredPropertiesOf(
                                task

            || (typeArguments[0].isString && (typeArguments[1].isStarProjectionTypeUsage || typeArguments[1].isAny))
        )


private
object SourceNames {
    const val javaClass = "java.lang.Class"
    const val groovyClosure = "groovy.lang.Closure"
    const val gradleAction = "org.gradle.api.Action"
    const val gradleTypeOf = "org.gradle.api.reflect.TypeOf"

            val qualifiedName = psiClass.qualifiedName
            val packageName = (psiClass.containingFile as? PsiJavaFile)?.packageName ?: ""
            if (qualifiedName != null) {
                val javaClass = JavaClassImpl(javaElementSourceFactory.createPsiSource(psiClass))
                val relativeName = if (packageName.isEmpty()) qualifiedName else qualifiedName.substring(packageName.length + 1)

    public CallInterceptingMetaClass(
        MetaClassRegistry registry,
        Class<?> javaClass,
        MetaClass adaptee,
        InstrumentedGroovyCallsTracker callsTracker,
        CallInterceptorResolver interceptorResolver
    ) {
        super(registry, javaClass);
        this.adaptee = adaptee;
        this.callsTracker = callsTracker;
        this.interceptorResolver = interceptorResolver;

        is DataType.NullType -> error("Null type can't appear in property types")
        is DataType.UnitType -> error("Unit can't appear in property types")
        else -> { error("Unhandled data type: ${type.javaClass.simpleName}") }
    }
}


fun reflectData(
    identity: OperationId,
    type: DataClass,
    objectOrigin: ObjectOrigin,
    context: ReflectionContext

    val futureKotlinDslPluginVersion: String =
        futurePluginVersions["org.gradle.kotlin.kotlin-dsl"] as String

    private
    fun loadPropertiesFromResource(name: String): Properties? =
        javaClass.getResourceAsStream(name)?.use {
            Properties().apply { load(it) }
        }

    private
    val testRepositoryPaths: List<String>
        get() = listOfNotNull(