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

public class UpToDateResult extends AfterExecutionResult {
    private final ImmutableList<String> executionReasons;
    private final OriginMetadata reusedOutputOriginMetadata;

    public UpToDateResult(AfterExecutionResult parent, ImmutableList<String> executionReasons) {
        super(parent);

    private static final Logger LOGGER = LoggerFactory.getLogger(SkipUpToDateStep.class);

    private final Step<? super C, ? extends AfterExecutionResult> delegate;

    public SkipUpToDateStep(Step<? super C, ? extends AfterExecutionResult> delegate) {
        this.delegate = delegate;
    }

    @Override
    public UpToDateResult execute(UnitOfWork work, C context) {

        this.delegate = delegate;
    }

    @Override
    public UpToDateResult execute(UnitOfWork work, C context) {
        AfterExecutionResult result = delegate.execute(work, context);
        return new UpToDateResult(result, NO_HISTORY);
    }

    private final Step<? super IncrementalCachingContext, ? extends UpToDateResult> delegate;

    public ResolveIncrementalCachingStateStep(
        BuildCacheController buildCache,
        boolean emitDebugLogging,
        Step<? super IncrementalCachingContext, ? extends UpToDateResult> delegate
    ) {
        super(buildCache, emitDebugLogging);
        this.delegate = delegate;
    }

    private final Step<? super NonIncrementalCachingContext, ? extends UpToDateResult> delegate;

    public ResolveNonIncrementalCachingStateStep(
        BuildCacheController buildCache,
        boolean emitDebugLogging,
        Step<? super NonIncrementalCachingContext, ? extends UpToDateResult> delegate
    ) {
        super(buildCache, emitDebugLogging);
        this.delegate = delegate;
    }

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);
        this.cachingState = cachingState;
    }

        cachingState.apply(
            enabled -> logCacheKey(enabled.getCacheKeyCalculatedState().getKey(), work),
            disabled -> logDisabledReasons(disabled.getDisabledReasons(), work)
        );

        UpToDateResult result = executeDelegate(work, context, cachingState);
        return new CachingResult(result, cachingState);
    }

    def buildCache = Mock(BuildCacheController)
    S step
    def delegateResult = Stub(UpToDateResult)
    def beforeExecutionState = Stub(BeforeExecutionState) {
        inputFileProperties >> ImmutableSortedMap.of()
        inputProperties >> ImmutableSortedMap.of()