import java.util.function.Consumer;
import java.util.function.Function;

public class CachingState {
    public static final CachingState NOT_DETERMINED = disabledWithoutInputs(new CachingDisabledReason(CachingDisabledReasonCategory.UNKNOWN, "Cacheability was not determined"));

    private final Either<Enabled, Disabled> delegate;

    private CachingState(Either<Enabled, Disabled> delegate) {
        this.delegate = delegate;
    }

import org.gradle.internal.execution.caching.CachingState;
import org.gradle.internal.execution.history.ExecutionOutputState;

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

public class CachingResult extends UpToDateResult {

    private final CachingState cachingState;

    public CachingResult(UpToDateResult parent, CachingState cachingState) {
        super(parent);

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

public class IncrementalCachingContext extends IncrementalChangesContext implements CachingContext {

    private final CachingState cachingState;

    public IncrementalCachingContext(IncrementalChangesContext parent, CachingState cachingState) {
        super(parent);
        this.cachingState = cachingState;
    }

    /**

        super(parent);
        this.inputChanges = inputChanges;
        this.cachingState = cachingState;
    }

    protected InputChangesContext(InputChangesContext parent) {
        this(parent, parent.getInputChanges().orElse(null), parent.getCachingState());
    }

    public Optional<InputChangesInternal> getInputChanges() {

                    ]
                    getSnapshot() >> snapshots
                }
            )
        }
        def cachingState = CachingState.enabled(Mock(BuildCacheKey), beforeExecutionState)
        def buildOpResult = createSnapshotInputsBuildOperationResult(
            cachingState,
            [inputFileProperty] as Set
        )

        when:
        buildOpResult.visitInputFileProperties(visitor)

        private final Try<ExecutionEngine.Execution> execution;
        private final CachingState cachingState;
        private final Optional<OriginMetadata> originMetadata;
        private final ImmutableList<String> executionReasons;

        public ExecuteWorkResult(
            Try<ExecutionEngine.Execution> execution,
            CachingState cachingState,
            Optional<OriginMetadata> originMetadata,

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

public class NonIncrementalCachingContext extends ValidationFinishedContext implements CachingContext {

    private final CachingState cachingState;

    public NonIncrementalCachingContext(ValidationFinishedContext parent, CachingState cachingState) {
        super(parent);
        this.cachingState = cachingState;
    }

    /**

    private CachingState calculateCachingStateWithNoCapturedInputs(UnitOfWork work) {
        if (!buildCache.isEnabled()) {
            return BUILD_CACHE_DISABLED_STATE;
        }
        return work.shouldDisableCaching(null)
            .map(CachingState::disabledWithoutInputs)
            .orElse(CachingState.NOT_DETERMINED);
    }

        }

        @Override
        public Optional<OriginMetadata> getReusedOutputOriginMetadata() {
            return Optional.empty();
        }

        @Override
        public CachingState getCachingState() {
            return CachingState.NOT_DETERMINED;
        }
    };

        return Optional.empty();
    }

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