// Initialize the super types of the bean type, as this does not seem to happen via the generated constructors
        maybeInit(beanType)
        if (GroovyObjectSupport::class.java.isAssignableFrom(beanType)) {
            // Run the `GroovyObjectSupport` constructor, to initialize the metadata field
            return newConstructorForSerialization(beanType, GroovyObjectSupport::class.java.getConstructor())
        } else {

        allReceiversResolved.mapNotNull { (it as? ObjectOrigin.CustomConfigureAccessor)?.let { custom -> custom.receiver to custom } }
            .groupBy(keySelector = { it.first }, valueTransform = { it.second }).mapValues { it.value.distinct() }
    }

    val lambdaAccessorsUsedByReceiver: Map<ObjectOrigin, List<ObjectOrigin.ConfiguringLambdaReceiver>> = run {

            union(key, value.node)
        }

        return buildMap {
            assignmentByNode.forEach { (lhs, _) ->
                put(lhs.propertyReferenceResolution, run {
                    when (val result = get(lhs)) {
                        is ResolutionNode.PrimitiveValue -> {
                            val assignmentMethod = assignmentMethodByProperty.getValue(lhs)

class UnitCodecTest : AbstractUserTypeCodecTest() {

    @Test
    @Issue("https://github.com/gradle/gradle/issues/25560")
    fun `same Unit instance is used upon restore`() {
        configurationCacheRoundtripOf(Unit).run {
            assertThat(this, sameInstance(Unit))
        }
    }

    }

    private
    fun record(operation: suspend WriteContext.() -> Unit) {
        operations.add(operation)
    }

    override fun defaultWriteObject() = record {
        beanStateWriterFor(beanType).run {
            writeStateOf(bean)
        }
    }

    override fun writeInt(`val`: Int) = record {
        writeInt(`val`)
    }

    override fun writeUTF(str: String) = record {
        writeString(str)

  cannot succeed; no artifact downloads can take place, regardless of whether
  they are snapshot versions; artifact deployment cannot take place; certain
  types of tests cannot be setup, since the container used to run them cannot be
  reached or started.

  All of these operations will produce their own unique errors in the absence of
  a coordinated offline strategy. In addition, efforts to unite these failing

        ConfigurationCacheFingerprintChecker(CacheFingerprintCheckerHost(host)).run {
            checkBuildScopedFingerprint()
        }

    suspend fun ReadContext.checkProjectScopedFingerprint(host: Host): CheckedFingerprint =
        ConfigurationCacheFingerprintChecker(CacheFingerprintCheckerHost(host)).run {
            checkProjectScopedFingerprint()
        }

        },
        exception,
        documentationSection = RequirementsBuildListeners
    )

    private
    fun isBuildSrcBuild(invocationSource: Any): Boolean =
        (invocationSource as? GradleInternal)?.run {
            !isRootBuild && identityPath.name == BUILD_SRC
        } ?: false

    private
    fun atConfigurationTime() = configurationTimeBarrier.isAtConfigurationTime

    private

        is WrappedFileCollectionTreeSpec -> spec.collection.asFileTree
        is DirectoryTreeSpec -> fileCollectionFactory.treeOf(directoryFileTreeFactory.create(spec.file, spec.patterns))
        is GeneratedTreeSpec -> spec.spec.run {
            fileCollectionFactory.generated(tmpDir, fileName, fileGenerationListener, contentGenerator)
        }
        is ZipTreeSpec -> fileOperations.zipTree(spec.file) as FileTreeInternal

    }

    override suspend fun ReadContext.decode(): WorkNodeAction {
        // TODO - should discard from graph instead
        return object : WorkNodeAction {
            override fun run(context: NodeExecutionContext) {
                // Ignore
            }
        }
    }