import org.gradle.internal.execution.caching.CachingState
import org.gradle.operations.execution.FilePropertyVisitor

class SnapshotTransformInputsBuildOperationResultTest extends AbstractSnapshotInputsBuildOperationResultTest<SnapshotTransformInputsBuildOperationResult, FilePropertyVisitor> {
    @Override

    private final Set<InputFilePropertySpec> inputFilePropertySpecs;

    public SnapshotTransformInputsBuildOperationResult(CachingState cachingState, Set<InputFilePropertySpec> inputFilePropertySpecs) {
        super(cachingState);
        this.inputFilePropertySpecs = inputFilePropertySpecs;
    }

    @Override
    public void visitInputFileProperties(FilePropertyVisitor visitor) {

    private final List<String> executionReasons;

    public ExecuteTaskBuildOperationResult(TaskStateInternal taskState, CachingState cachingState, @Nullable OriginMetadata originMetadata, boolean incremental, List<String> executionReasons) {
        this.taskState = taskState;
        this.cachingState = cachingState;
        this.originMetadata = originMetadata;
        this.incremental = incremental;

        _ * context.validationProblems >> ImmutableList.of()
        1 * delegate.execute(work, { CachingContext context ->
            context.cachingState.whenDisabled().map { it.disabledReasons*.category }.get() == [CachingDisabledReasonCategory.BUILD_CACHE_DISABLED]
            context.cachingState.whenDisabled().map { it.disabledReasons*.message }.get() == ["Build cache is disabled"]
        }) >> delegateResult
    }

                .map(PreviousExecutionState::getCacheKey));
    }

    @Override
    protected UpToDateResult executeDelegate(UnitOfWork work, C context, CachingState cachingState) {
        return delegate.execute(work, new IncrementalCachingContext(context, cachingState));
    }

        this.logger = logger;
    }

    @Override
    public final CachingState createCachingState(BeforeExecutionState beforeExecutionState, HashCode cacheKey, ImmutableList<CachingDisabledReason> cachingDisabledReasons) {
        if (cachingDisabledReasons.isEmpty()) {
            return CachingState.enabled(new DefaultBuildCacheKey(cacheKey), beforeExecutionState);
        } else {

            _ * getOutputFilesProducedByWork() >> this.outputFilesProducedByWork
            _ * getOriginMetadata() >> originMetadata
        })

        _ * context.cachingState >> CachingState.enabled(new DefaultBuildCacheKey(cacheKey), beforeExecutionState)
        _ * delegateResult.execution >> Try.successful(Mock(Execution))

        then:

import org.gradle.internal.execution.caching.CachingState

class SnapshotTaskInputsBuildOperationResultTest extends AbstractSnapshotInputsBuildOperationResultTest<SnapshotTaskInputsBuildOperationResult, SnapshotTaskInputsBuildOperationType.Result.InputFilePropertyVisitor> {
    @Override
    SnapshotTaskInputsBuildOperationResult createSnapshotInputsBuildOperationResult(CachingState cachingState, Set<InputFilePropertySpec> inputFilePropertySpecs) {

        !result.afterExecutionOutputState.present
        result.duration == delegateDuration
        assertNoOperation()

        1 * delegate.execute(work, _) >> delegateResult
        _ * context.cachingState >> CachingState.disabledWithoutInputs(new CachingDisabledReason(CachingDisabledReasonCategory.UNKNOWN, "Unknown"))
        0 * _
    }

    def "fails if snapshotting outputs fail"() {

@NonNullApi
public abstract class BaseSnapshotInputsBuildOperationResult implements CustomOperationTraceSerialization {

    @VisibleForTesting
    final CachingState cachingState;

    public BaseSnapshotInputsBuildOperationResult(CachingState cachingState) {
        this.cachingState = cachingState;
    }

    protected abstract Map<String, Object> fileProperties();

    @Nullable
    public Map<String, byte[]> getInputValueHashesBytes() {