def delegateResult = Mock(WorkspaceResult)
        def originMetadata = Stub(OriginMetadata) {
            buildInvocationId >> "123245"
        }

        def execution = step.executeDeferred(work, context, cache)

        when:
        def cacheResult = execution.completeAndGet()

        then:
        cacheResult.get() == delegateOutput

                return executeStep.execute(work, createExecutionRequestContext());
            }

            @Override
            public <T> Deferrable<Try<T>> executeDeferred(Cache<Identity, IdentityCacheResult<T>> cache) {
                return executeStep.executeDeferred(work, createExecutionRequestContext(), cache);
            }
        };
    }

        return delegate.execute(work, createIdentityContext(work, context));
    }

    @Override
    public <T> Deferrable<Try<T>> executeDeferred(UnitOfWork work, C context, Cache<Identity, IdentityCacheResult<T>> cache) {
        return delegate.executeDeferred(work, createIdentityContext(work, context), cache);
    }

    @Nonnull
    private IdentityContext createIdentityContext(UnitOfWork work, C context) {

import org.gradle.internal.execution.UnitOfWork.Identity;

public interface DeferredExecutionAwareStep<C extends Context, R extends Result> extends Step<C, R> {
    <T> Deferrable<Try<T>> executeDeferred(UnitOfWork work, C context, Cache<Identity, IdentityCacheResult<T>> cache);

        def cache = new ManualEvictionInMemoryCache<UnitOfWork.Identity, Try<Object>>()

        when:
        def executedResult = executeDeferred(work, cache)

        then:
        executedResult == "deferred"

        when:
        def cachedResult = executeDeferred(work, cache)

        then:
        cachedResult == "cached"
    }

         * The work is looked up by its {@link UnitOfWork.Identity identity} in the given cache.
         */
        <T> Deferrable<Try<T>> executeDeferred(Cache<Identity, IdentityCacheResult<T>> cache);
    }

    interface Result {
        Try<Execution> getExecution();

        CachingState getCachingState();

        /**

    }

    @Override
    public R execute(UnitOfWork work, C context) {
        return delegate.execute(work, context);
    }

    @Override
    public <T> Deferrable<Try<T>> executeDeferred(UnitOfWork work, C context, Cache<Identity, IdentityCacheResult<T>> cache) {
        Identity identity = context.getIdentity();
        IdentityCacheResult<T> cacheResult = cache.getIfPresent(identity);

                    cachingDisabledByProperty
                );
            }
        }
        return effectiveEngine.createRequest(execution)
            .executeDeferred(identityCache)
            .map(result -> result
                .map(successfulResult -> successfulResult.resolveForInputArtifact(inputArtifact))