return new OriginMetadata(
            buildInvocationId,
            buildCacheKey,
            executionTime
        );
    }

    @Override
    public void write(Encoder encoder, OriginMetadata originMetadata) throws IOException {
        encoder.writeString(originMetadata.getBuildInvocationId());
        hashCodeSerializer.write(encoder, originMetadata.getBuildCacheKey());

import org.gradle.caching.internal.origin.OriginMetadata
import org.gradle.internal.hash.TestHashCodes
import org.gradle.internal.serialize.SerializerSpec

import java.time.Duration

class OriginMetadataSerializerTest extends SerializerSpec {

    def serializer = new OriginMetadataSerializer()

    def "can serialize and deserialize origin metadata"() {

    def executionHistoryStore = Mock(ExecutionHistoryStore)
    def cacheKey = TestHashCodes.hashCodeFrom(1234)

    def originMetadata = Mock(OriginMetadata)
    def beforeExecutionState = Stub(BeforeExecutionState) {
        getImplementation() >> ImplementationSnapshot.of("Test", TestHashCodes.hashCodeFrom(123))

        )

        def originMetadata = Stub(OriginMetadata)

        def delegateOutputFiles = ImmutableSortedMap.copyOf(
            "outputDirectory": delegateOutputFileSnapshot
        )
        def delegateOutputState = Stub(ExecutionOutputState) {
            getOriginMetadata() >> originMetadata
            getOutputFilesProducedByWork() >> delegateOutputFiles
        }

    private void outputStored(Closure storeResult) {
        def originMetadata = Mock(OriginMetadata)
        def outputFilesProducedByWork = snapshotsOf("test": [])

        1 * delegateResult.afterExecutionOutputState >> Optional.of(Mock(AfterExecutionState) {
            1 * getOutputFilesProducedByWork() >> outputFilesProducedByWork
            1 * getOriginMetadata() >> originMetadata
        })

        File metadataFile = new File(workspace, METADATA_FILE);
        //noinspection IOStreamConstructor
        try (KryoBackedDecoder decoder = new KryoBackedDecoder(new FileInputStream(metadataFile))) {
            OriginMetadata originMetadata = originMetadataSerializer.read(decoder);

            int outputCount = decoder.readSmallInt();
            ImmutableListMultimap.Builder<String, HashCode> outputPropertyHashes = ImmutableListMultimap.builder();

        then:
        1 * buildOperationContext.setResult(_ as UnpackOperationResult) >> { UnpackOperationResult unpackResult ->
            assert unpackResult.archiveEntryCount == 123
        }

        then:
        result.artifactEntryCount == 123
        result.originMetadata == originMetadata

 * limitations under the License.
 */

package org.gradle.internal.execution.steps;

import com.google.common.collect.ImmutableList;
import org.gradle.caching.internal.origin.OriginMetadata;
import org.gradle.internal.Try;
import org.gradle.internal.execution.ExecutionEngine;
import org.gradle.internal.execution.history.ExecutionOutputState;

import javax.annotation.Nullable;
import java.time.Duration;

                OriginMetadata originMetadata = createOriginMetadata(cacheKeyCalculatedState, result, timer);
                operationContext.setResult(Operation.Result.INSTANCE);
                return new DefaultExecutionOutputState(result.getExecution().isSuccessful(), outputsProducedByWork, originMetadata, false);
            },
            BuildOperationDescriptor

    }
    def originMetadata = Stub(OriginMetadata)
    def delegateResult = Stub(CachingResult) {
        getDuration() >> Duration.ofSeconds(1)
        getExecution() >> Try.successful(Stub(ExecutionEngine.Execution))
        getAfterExecutionOutputState() >> Optional.of(new DefaultExecutionOutputState(true, ImmutableSortedMap.of(), originMetadata, false))
    }

    def work1Started = new CountDownLatch(1)