return delegateResult
        }

        then:
        1 * immutableWorkspaceMetadataStore.storeWorkspaceMetadata(temporaryWorkspace, _) >> { File workspace, ImmutableWorkspaceMetadata metadata ->
            metadata.originMetadata == delegateOriginMetadata
        }

        then:
        1 * fileSystemAccess.moveAtomically(temporaryWorkspace.absolutePath, immutableWorkspace.absolutePath) >> { String from, String to ->

    def factory = new OriginMetadataFactory(
        buildInvocationId,
        { it.gradleVersion = "3.0" }
    )
    def buildCacheKey = TestHashCodes.hashCodeFrom(1234)

    def "converts to origin metadata"() {
        def origin = new Properties()
        def writer = factory.createWriter("identity", CacheableEntity, buildCacheKey, Duration.ofMillis(10))
        def baos = new ByteArrayOutputStream()
        writer.execute(baos)

    private final MethodMetaData metaData
    private final List<Element> comment
    private final ClassMetaData referringClass

    MethodDoc(MethodMetaData metaData, List<Element> comment) {
        this(metaData.ownerClass, metaData, comment)
    }

    MethodDoc(ClassMetaData referringClass, MethodMetaData metaData, List<Element> comment) {
        this.metaData = metaData
        this.referringClass = referringClass

        mixinClasses.each { mixin ->
            mixin.classMethods.each { method ->
                methods << method.forClass(targetClass)
            }
        }
        return methods.sort { it.metaData.overrideSignature }
    }

    List<BlockDoc> getExtensionBlocks() {
        List<BlockDoc> blocks = []
        mixinClasses.each { mixin ->
            mixin.classBlocks.each { block ->

        def metadata = metadataStore.getTypeMetadata(TypeWithUnannotatedProperties)

        then:
        metadata.propertiesMetadata.propertyName == ["useful"]
        collectProblems(metadata) == [
            missingAnnotationMessage { property('bad1').missingInputOrOutput().includeLink() },

        }

        //updating/modifying the metadata and making sure every type reference across the metadata is fully qualified
        //so, the superClassName, interfaces and types needed by declared properties and declared methods will have fully qualified name
        TypeNameResolver resolver = new TypeNameResolver(repository)
        repository.each { name, metaData ->
            fullyQualifyAllTypeNames(metaData, resolver)
        }

        def fileName = repositoryFile.name
        if (fileName.startsWith('maven-metadata.xml')) {
            if (fileName == 'maven-metadata.xml') {
                return clearLastUpdatedElementOf(repositoryFile.text)
            }
            // Ignore contents of maven-metadata.xml.sha256, etc, because hashes will most likely
            // change between runs due to <lastUpdated /> differences.

        1 * progressEventEmitter.emitNowIfCurrent({ it ->
            it.originBuildInvocationId == originMetadata.buildInvocationId
        })
        0 * _
    }

    def "returns origin metadata of current build when not re-used"() {
        def delegateOutput = Mock(Object)
        def delegateResult = Mock(WorkspaceResult)
        def originMetadata = Stub(OriginMetadata) {
            buildInvocationId >> "12345"

        def output = new ByteArrayOutputStream()

        new TarArchiveOutputStream(output).withCloseable { tar ->
            def metadataBytes = "".bytes
            def metadataEntry = new TarArchiveEntry("METADATA")
            metadataEntry.size = metadataBytes.length
            tar.putArchiveEntry(metadataEntry)
            tar.write(metadataBytes)
            tar.closeArchiveEntry()

import java.time.Duration

class OriginMetadataSerializerTest extends SerializerSpec {

    def serializer = new OriginMetadataSerializer()

    def "can serialize and deserialize origin metadata"() {
        def originMetadata = new OriginMetadata("test-invocation-id", TestHashCodes.hashCodeFrom(1234), Duration.ofSeconds(123))

        expect:
        serialize(originMetadata, serializer) == originMetadata
    }