@Override
    public void emitNow(@Nullable OperationIdentifier operationIdentifier, @Nullable Object details) {}

    @Override
    public void emitNowIfCurrent(Object details) {}

    @Override
    public void emitIfCurrent(long time, Object details) {}

    @Override
    public void emitNowForCurrent(Object details) {}

                    .details("Test")
                    .severity(Severity.ERROR)
            }
        }
        0 * _
        _ * buildOperationProgressEventEmitter.emitNowIfCurrent(_ as Object) >> {}
    }

    def "fails when there are multiple violations"() {
        expectReindentedValidationMessage()
        when:
        step.execute(work, context)

        then:

    void emit(OperationIdentifier operationIdentifier, long timestamp, @Nullable Object details);

    void emitNow(@Nullable OperationIdentifier operationIdentifier, @Nullable Object details);
    void emitNowIfCurrent(Object details);

    void emitIfCurrent(long time, Object details);

    void emitNowForCurrent(Object details);

        delegateResult.reusedOutputOriginMetadata >> Optional.of(originMetadata)

        1 * delegate.execute(work, context) >> delegateResult
        1 * progressEventEmitter.emitNowIfCurrent({ it ->
            it.originBuildInvocationId == originMetadata.buildInvocationId
        })
        0 * _
    }

    def "returns origin metadata of current build when not re-used"() {

    public void emitNow(@Nullable OperationIdentifier operationIdentifier, @Nullable Object details) {
        emit(operationIdentifier, clock.getCurrentTime(), details);
    }

    @Override
    public void emitNowIfCurrent(Object details) {
        emitIfCurrent(clock.getCurrentTime(), details);
    }

    @Override
    public void emitIfCurrent(long time, Object details) {

    private <T> void emitExecuteDeferredProgressDetails(UnitOfWork work, Identity identity, IdentityCacheResult<T> cacheResult) {
        cacheResult.getOriginMetadata().ifPresent(originMetadata ->
            progressEventEmitter.emitNowIfCurrent(new DefaultExecuteDeferredWorkProgressDetails(
                work.getBuildOperationWorkType().orElse(null),
                identity,
                originMetadata
            ))
        );
    }

        BuildCacheRemoteDisabledDueToFailureProgressDetails.BuildCacheOperationType operationType = convertToBuildOperationType(operation);
        buildOperationProgressEventEmitter.emitNowIfCurrent(new RemoteDisabledDueToFailureProgressDetails(key, failure, operationType));
    }

        }
    }

    private void fireDeprecatedUsageBuildOperationProgress(DeprecatedFeatureUsage usage, ProblemDiagnostics diagnostics) {
        if (progressEventEmitter != null) {
            progressEventEmitter.emitNowIfCurrent(new DefaultDeprecatedUsageProgressDetails(usage, diagnostics));
        }
    }

    public void reset() {
        problemStream = NoOpProblemDiagnosticsFactory.EMPTY_STREAM;

                    .orElse(FileCollectionFactory.empty())));
    }

    protected void emitIdentifyTransformExecutionProgressDetails(TransformWorkspaceIdentity transformWorkspaceIdentity) {
        progressEventEmitter.emitNowIfCurrent(new DefaultIdentifyTransformExecutionProgressDetails(
            inputArtifact,
            transformWorkspaceIdentity,
            transform,
            subject.getInitialComponentIdentifier()));
    }